diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2164a92..4090bc3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,16 +2,22 @@
 
 ## [Unreleased]
 ### Added
+- GH-3: Title type announcement sender (@tajobe)
 - MIT license
 
 ### Changed
 - MC 1.21, Java 21, Kotlin 2.1
+- **BREAKING**: New config format
 
 ### Fixed
 - Config Auto-reload is now a repeating task as intended
 - Config actually created on first run
 - Copy updated default header when config is updated
 
+### Removed
+- Offline variant is now the default jar, no longer producing an "online" version
+- debugMode option: log levels are controlled by the server's log4j configuration
+
 ## [1.0.0] - 2020-02-10
 ### Added
 - CHANGELOG
diff --git a/README.md b/README.md
index 64e3c79..3529972 100755
--- a/README.md
+++ b/README.md
@@ -6,9 +6,9 @@ Messages can be sent server-wide or controlled by permissions after a delay and
 
 ## Features
 
-- Timed server-wide announcements/news messages
+- Timed server-wide announcements/news messages sent as either a chat message, boss bar, or title/subtitle
 - Easily configurable
-- Configure one-time or repeating messages
+- Configure one-time (per reload) or repeating/rotating messages
 - Extensive Permissions support - configure messages to only send to users including or excluding certain permission nodes
 - Optional debug mode to track down who is/isn't receiving messages and why
 - Automatic config reloading to get new messages
@@ -17,66 +17,91 @@ Messages can be sent server-wide or controlled by permissions after a delay and
 
 ## Configuration
 
-Format:
-```yaml
-config-version(int): **DO NOT EDIT**, used to migrate configurations as the format changes
-auto-reloadconfig(int): <Time in minutes to check/reload config for message updates(0 for off)>
-  NOTE: When config is reloaded, will reset delays for messages and cause one-time messages to resend
-debug-mode(boolean): <Should we pring debug to server.log(true/false)?>
-  NOTE: Look for fine and finer level log messages in server.log
-announcements: Add announcements below to this section
-  <message label>(String, must be unique):
-    message(String, required) OR messages(String list, see sample config): <Message to send>
-    random-order(boolean, optional): <if list of messages should be sent in random order>
-    sender(String, optional): <Message Sender(chat or boss, default: chat)>
-    bar(section, optional):
-      hold(int, optional): <Time in sections for bar to be displayed on announce>
-      color(String, optional): <bar color(https://hub.spigotmc.org/javadocs/spigot/org/bukkit/boss/BarColor.html)>
-      style(String, optional): <bar style(https://hub.spigotmc.org/javadocs/spigot/org/bukkit/boss/BarStyle.html)>
-      animate(section, optional):
-        enable(boolean, optional): <if bar should animate hold time>
-        reverse(boolean, optional): <if animation should be reversed>
-    delay(int, optional - default 0): <Delay to send message on in seconds>
-    repeat(int, optional): <time between repeat sendings of the message in seconds>
-    includesperms(String list, optional):
-      - <only send to those with this perm>
-      - <and this one>
-    excludesperms(String list, optional):
-      - <don't send to those with this perm>
-      - <and this one>
-```
-**Note**: For permissions, includes are applied first, then excludes are taken out
+- `autoReload`(duration*, optional): Time between automatically reloading plugin configuration, unset or `0m` for off
+- `announcements`(Announcement list): list of announcement configurations, see below for detail
+  - General announcement configuration:
+    - `type`(Announcement type): Type of announcement: `Chat`, `Title`, or `Boss`
+    - `messages` OR `message`(Message list): Message(s) to send, depends on type (see sample and description below)
+    - `random`(boolean, optional): if list of messages should be sent in random order
+    - `delay`(duration*, optional - default 0): Delay after loading to send message
+    - `repeat`(duration*, optional): time between sending/repeating each message
+    - `includesPermissions`**(String list, optional): Only send announcement to players with these permissions
+    - `excludesPermissions`**(String list, optional): Exclude players with these permissions from receiving the announcement
+    - `<additional options depending on announcement type>`
+  - `Chat` type announcement:
+    - `messages`(String list): Message(s) to send
+  - `Boss` type announcement:
+    - `hold`(duration*): Time for boss bar to be on screen
+    - `color`(BarColor): Color of bar, one of PINK, BLUE, RED, GREEN, YELLOW, PURPLE, WHITE
+    - `style`(BarStyle): Style of bar, one of SOLID, SEGMENTED_6, SEGMENTED_10, SEGMENTED_12, SEGMENTED_20
+    - `animate`(boolean): if bar should animate over hold time
+    - `reverseAnimation`(boolean): if animation should be reversed
+    - `messages`(BossBarMessage list):
+      - `message`(string): message string
+      - ...boss bar config overrides per message eg hold, color, style, animate, etc...
+  - `Title` type announcement:
+    - `fadeIn`(duration*): Time it takes for title to fade in
+    - `stay`(duration*): Time for title to stay on screen
+    - `fadeOut`(duration*): Time it takes for title to fade out
+    - `messages`(TitleMessage list):
+      - `title`(string): title string
+      - `subtitle`(string): subtitle string, appears below title slightly smaller
+      - ...title config overrides eg fadeIn, stay, fadeOut...
+- `config-version`: **Internal use for configuration migrations, do not edit**
+
+<sub>
+*Durations are in the form '10s', '5m', '1h', or ISO-8601 duration. See [parse](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.time/-duration/-companion/parse.html).
+
+**For permissions, includes are applied first, then excludes are taken out
+</sub>
+
 
 ### Example
 
 ```yaml
-config-version: 1
-auto-reloadconfig: 20
-debug-mode: false
+autoReload: 10m
 announcements:
-  repeating-example:
-    messages:
-      - This is an automatically generated repeating message!
-    delay: 15
-    repeat: 60
-  permissions-example:
-    messages:
-      - This is another automatically generated repeating message for people with build permission!
-    delay: 30
-    repeat: 60
-    includesperms:
-    - permissions.build
-  one-time-example:
-    messages:
-      - This is an automatically generated one-time message!
-    delay: 45
-  message-group-example:
-    messages:
-      - This is an automatically generated sequential message group (1 of 3)!
-      - This is an automatically generated sequential message group (2 of 3)!
-      - This is an automatically generated sequential message group (3 of 3)!
-    delay: 30
-    repeat: 30
-    sender: bossbar
-    random-order: false
+    - type: Chat
+      delay: 30s
+      repeat: 2m
+      includesPermissions:
+          - permissions.build
+          - another.permission
+      excludesPermissions:
+          - permissions.admin
+      messages:
+          - hello
+          - world
+    - type: Chat
+      repeat: 1m 40s
+      messages:
+          - abc
+          - xyz
+    - type: Title
+      repeat: 30s
+      messages:
+          - title: Title!
+            subtitle: Subtitle!
+          - title: Title only custom durations
+            fadeIn: 100ms
+            stay: 10s
+            fadeOut: 1s
+      fadeIn: 500ms
+      stay: 5s
+      fadeOut: 500ms
+    - type: Boss
+      random: true
+      repeat: 15s
+      messages:
+          - message: eyy
+          - message: custom bar config
+            hold: 10s
+            color: GREEN
+            style: SEGMENTED_20
+            reverseAnimation: true
+      hold: 5s
+      color: PURPLE
+      style: SOLID
+      animate: true
+config-version: 1
 ```
diff --git a/build.gradle.kts b/build.gradle.kts
index d871561..8013259 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -59,9 +59,17 @@ kotlin {
     jvmToolchain(21)
 }
 
+val shadowJarOnly: Boolean = project.property("shadowJarOnly")?.toString()?.toBoolean() ?: false
+val runtimeClasspath by configurations.runtimeClasspath
+
 dependencies {
     compileOnly(libs.spigot)
     implementation(libs.kotlinLogger)
+    implementation(libs.jacksonKotlin)
+    implementation(libs.jacksonDataformatYaml)
+    implementation(kotlin("stdlib"))
+
+    testImplementation(libs.spigot)
 }
 
 tasks {
@@ -70,8 +78,10 @@ tasks {
     }
 
     processResources {
-        // inject runtime libraries into online plugin variant
-        val libraries = configurations.runtimeClasspath.get().resolvedConfiguration.resolvedArtifacts
+        inputs.property("shadowJarOnly", shadowJarOnly)
+
+        // inject "online" libraries into online plugin variant
+        val libraries = runtimeClasspath.resolvedConfiguration.resolvedArtifacts
             .joinToString("\n  - ", prefix = "\n  - ") { artifact ->
                 val id = artifact.moduleVersion.id
                 "${id.group}:${id.name}:${id.version}"
@@ -102,19 +112,29 @@ tasks {
         }
     }
 
-    jar {
-        exclude("offline-plugin.yml")
-    }
-
     // offline jar should be ready to go with all dependencies
     shadowJar {
-        minimize()
-        archiveClassifier.set("offline")
+        mergeServiceFiles()
+        minimize {
+            // if present, kotlin-reflect must be excluded from minimization
+            exclude(dependency("org.jetbrains.kotlin:kotlin-reflect"))
+        }
+        archiveClassifier.set(if (shadowJarOnly) "" else "offline")
         exclude("plugin.yml")
         rename("offline-plugin.yml", "plugin.yml")
 
         // avoid classpath conflicts/pollution via relocation
         isEnableRelocation = true
         relocationPrefix = "${project.group}.${project.name.lowercase()}.libraries"
+
+        // if using reflection, don't relocate kotlin:
+        // shadow relocation doesn't relocate certain metadata breaking some synthetic classes in the case of reflection (used by jackson, for example)
+        // see also: https://github.com/JetBrains/Exposed/issues/1353
+        if (runtimeClasspath.resolvedConfiguration.resolvedArtifacts.any { it.name == "kotlin-reflect" }) {
+            logger.warn("Detected kotlin-reflect in runtime classpath, not relocating kotlin! Proceed with caution.")
+            relocate("kotlin", "kotlin")
+        }
     }
+
+    build { dependsOn(shadowJar) }
 }
diff --git a/gradle.properties b/gradle.properties
index 7fc6f1f..55177ae 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1,3 @@
 kotlin.code.style=official
+# only produce an "offline" jar due to classpath challenges with jackson and reflection
+shadowJarOnly=true
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index a35a4c9..49cd6dc 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,5 +1,6 @@
 [versions]
 axionRelease = "1.18.18"
+jackson = "2.19.0"
 kotlin = "2.1.21"
 kotlinLogger = "7.0.7"
 ktlintGradle = "12.2.0"
@@ -14,5 +15,7 @@ ktlint = { id = "org.jlleitschuh.gradle.ktlint", version.ref = "ktlintGradle"}
 shadow = { id = "com.gradleup.shadow", version.ref = "shadow"}
 
 [libraries]
+jacksonKotlin = { group = "com.fasterxml.jackson.module", name = "jackson-module-kotlin", version.ref = "jackson" }
+jacksonDataformatYaml = { group = "com.fasterxml.jackson.dataformat", name = "jackson-dataformat-yaml", version.ref = "jackson" }
 kotlinLogger = { group = "io.github.oshai", name = "kotlin-logging", version.ref = "kotlinLogger" }
 spigot = { group = "org.spigotmc", name = "spigot-api", version.ref = "spigot" }
diff --git a/src/main/kotlin/org/simplemc/simpleannounce/Extensions.kt b/src/main/kotlin/org/simplemc/simpleannounce/Extensions.kt
index d5cc42d..e326d6e 100644
--- a/src/main/kotlin/org/simplemc/simpleannounce/Extensions.kt
+++ b/src/main/kotlin/org/simplemc/simpleannounce/Extensions.kt
@@ -3,6 +3,7 @@ package org.simplemc.simpleannounce
 import org.bukkit.configuration.ConfigurationSection
 import org.bukkit.configuration.file.FileConfigurationOptions
 import org.bukkit.configuration.file.YamlConfiguration
+import kotlin.time.Duration
 
 fun String.oneOf(ignoreCase: Boolean, vararg values: String): Boolean =
     values.any { it.equals(this, ignoreCase = ignoreCase) }
@@ -11,6 +12,8 @@ fun String.oneOf(vararg values: String): Boolean = oneOf(false, *values)
 
 fun String.oneOfIgnoreCase(vararg values: String): Boolean = oneOf(true, *values)
 
+val Duration.inTicks: Long get() = this.inWholeMilliseconds / 50
+
 /**
  * Get a string list if and only if it exists in the config (ignoring defaults).
  * If the path does not exist, returns empty list
diff --git a/src/main/kotlin/org/simplemc/simpleannounce/SimpleAnnounce.kt b/src/main/kotlin/org/simplemc/simpleannounce/SimpleAnnounce.kt
index 2946409..7b59152 100644
--- a/src/main/kotlin/org/simplemc/simpleannounce/SimpleAnnounce.kt
+++ b/src/main/kotlin/org/simplemc/simpleannounce/SimpleAnnounce.kt
@@ -1,60 +1,81 @@
 package org.simplemc.simpleannounce
 
-import org.bukkit.ChatColor
-import org.bukkit.boss.BarColor
-import org.bukkit.boss.BarStyle
+import com.fasterxml.jackson.databind.DeserializationFeature
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.databind.module.SimpleModule
+import com.fasterxml.jackson.dataformat.yaml.YAMLGenerator
+import com.fasterxml.jackson.dataformat.yaml.YAMLMapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
 import org.bukkit.command.Command
 import org.bukkit.command.CommandSender
-import org.bukkit.configuration.ConfigurationSection
 import org.bukkit.plugin.java.JavaPlugin
-import org.simplemc.simpleannounce.message.Announcement
-import org.simplemc.simpleannounce.message.sender.BossBarSender
-import org.simplemc.simpleannounce.message.sender.ChatSender
-import java.util.logging.Level
+import org.simplemc.simpleannounce.config.DurationDeserializer
+import org.simplemc.simpleannounce.config.DurationSerializer
+import org.simplemc.simpleannounce.config.SimpleAnnounceConfig
+import org.simplemc.simpleannounce.sender.BossBarSender
+import org.simplemc.simpleannounce.sender.ChatSender
+import org.simplemc.simpleannounce.sender.TitleSender
+import java.io.File
+import kotlin.time.Duration
 
 class SimpleAnnounce : JavaPlugin() {
+    companion object {
+        private const val CONFIG_FILE_NAME = "config.yml"
+        private const val CONFIG_VERSION_KEY = "config-version"
+        private const val CURRENT_CONFIG_VERSION = 1
+        private const val RELOAD_COMMAND = "simpleannouncereload"
+
+        private val durationModule = SimpleModule()
+            .addDeserializer(Duration::class.java, DurationDeserializer())
+            .addSerializer(DurationSerializer())
+    }
+
+    private val objectMapper: ObjectMapper = YAMLMapper.builder()
+        .disable(YAMLGenerator.Feature.USE_NATIVE_TYPE_ID)
+        .build()
+        .registerKotlinModule()
+        .registerModule(durationModule)
+        .enable(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)
+        .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+
     override fun onEnable() {
         saveDefaultConfig()
-        loadConfig()
-        checkNotNull(getCommand("simpleannouncereload")).setExecutor(::reloadCommand)
+        loadAnnouncementsFromConfig()
+        checkNotNull(getCommand(RELOAD_COMMAND)).setExecutor(::reloadCommand)
         logger.info { "${description.name} version ${description.version} enabled!" }
     }
 
     private fun reload() {
         reloadConfig()
-        loadConfig()
+        loadAnnouncementsFromConfig()
     }
 
-    private fun loadConfig() {
-        // cancel any old tasks
-        server.scheduler.cancelTasks(this)
-
-        updateConfig()
+    private fun loadAnnouncementsFromConfig() {
+        server.scheduler.cancelTasks(this) // clear any old tasks
+        migrateConfigToLatest()
 
-        // load debug mode
-        if (config.getBoolean("debug-mode", false)) {
-            logger.level = Level.FINER
-        }
+        val announcementConfig = objectMapper.readValue<SimpleAnnounceConfig>(File(dataFolder, CONFIG_FILE_NAME))
 
         // load auto-reload + create task to check again if necessary
-        val reloadTime = config.getLong("auto-reloadconfig", 0L)
-        if (reloadTime > 0L) {
-            val reloadTicks = reloadTime * 60 * 20
+        if (announcementConfig.autoReload?.isPositive() == true) {
+            val reloadTicks = announcementConfig.autoReload.inTicks
             server.scheduler.runTaskTimerAsynchronously(this, ::reload, reloadTicks, reloadTicks)
 
-            logger.fine { "Will reload config every $reloadTime minutes" }
+            logger.fine { "Will reload config every ${announcementConfig.autoReload}" }
         }
 
-        config.getConfigurationSection("announcements")?.getKeys(false)?.let { keys ->
-            keys.mapNotNull { config.getConfigurationSection("announcements.$it") }
-                .forEach {
-                    logger.fine { "Loading announcement '${it.name}'" }
-                    loadAnnouncementSender(loadAnnouncement(it), it)
-                }
+        // set up senders
+        announcementConfig.announcements.forEach { config ->
+            when (config) {
+                is SimpleAnnounceConfig.AnnouncementConfig.Chat -> ChatSender(this, config)
+                is SimpleAnnounceConfig.AnnouncementConfig.Boss -> BossBarSender(this, config)
+                is SimpleAnnounceConfig.AnnouncementConfig.Title -> TitleSender(this, config)
+            }
         }
     }
 
-    private fun updateConfig() {
+    private fun migrateConfigToLatest() {
         var updated = false
 
         // migrate each config version until we're at the latest (no more updates)
@@ -69,55 +90,25 @@ class SimpleAnnounce : JavaPlugin() {
         }
     }
 
-    private fun configVersionMigration() = when (config["config-version", 0]) {
-        1 -> false // this is the current version
+    private fun configVersionMigration() = when (config[CONFIG_VERSION_KEY, 0]) {
+        CURRENT_CONFIG_VERSION -> false // this is the current version
         else -> {
             // invalid or no config version set, bring in defaults
             config.options().copyDefaults(true)
-            config["config-version"] = 1
+            config[CONFIG_VERSION_KEY] = CURRENT_CONFIG_VERSION
             true
         }
     }
 
-    private fun loadAnnouncement(announcementConfig: ConfigurationSection) = Announcement(
-        label = announcementConfig.name,
-        messages = announcementConfig.getStringList("messages").map { ChatColor.translateAlternateColorCodes('&', it) },
-        permissionIncludes = announcementConfig.getStringListOrEmpty("includesperms"),
-        permissionExcludes = announcementConfig.getStringListOrEmpty("excludesperms"),
-        delay = announcementConfig.getInt("delay", 0),
-        period = if (announcementConfig.isSet("repeat")) announcementConfig.getInt("repeat") else null,
-        random = announcementConfig.getBoolean("random", false),
-    )
-
-    private fun loadAnnouncementSender(announcement: Announcement, announcementConfig: ConfigurationSection) =
-        when (announcementConfig.getString("sender", "chat")) {
-            "boss", "bossbar" -> BossBarSender(
-                plugin = this,
-                announcement = announcement,
-                holdTime = announcementConfig.getInt("bar.hold", 5),
-                color = BarColor.valueOf(checkNotNull(announcementConfig.getString("bar.color", "PURPLE")).uppercase()),
-                style = BarStyle.valueOf(checkNotNull(announcementConfig.getString("bar.style", "SOLID")).uppercase()),
-                animate = announcementConfig.getBoolean("bar.animate.enable", true),
-                reverse = announcementConfig.getBoolean("bar.animate.reverse", false),
-            )
-
-            "chat" -> ChatSender(this, announcement)
-            else ->
-                throw IllegalArgumentException("Invalid message sender configured on message '${announcement.label}'!")
-        }
-
     override fun onDisable() {
         server.scheduler.cancelTasks(this)
         logger.info { "${description.name} disabled." }
     }
 
     private fun reloadCommand(sender: CommandSender, command: Command, label: String, vararg args: String): Boolean {
-        reloadConfig()
-        loadConfig()
-
+        reload()
         logger.fine { "Config reloaded" }
         sender.sendMessage("SimpleAnnounce config reloaded.")
-
         return true
     }
 }
diff --git a/src/main/kotlin/org/simplemc/simpleannounce/config/DurationDeserializer.kt b/src/main/kotlin/org/simplemc/simpleannounce/config/DurationDeserializer.kt
new file mode 100644
index 0000000..e3490c0
--- /dev/null
+++ b/src/main/kotlin/org/simplemc/simpleannounce/config/DurationDeserializer.kt
@@ -0,0 +1,21 @@
+package org.simplemc.simpleannounce.config
+
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.databind.DeserializationContext
+import com.fasterxml.jackson.databind.JsonDeserializer
+import kotlin.time.Duration
+
+class DurationDeserializer : JsonDeserializer<Duration>() {
+    override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Duration? {
+        val text = p.text.trim()
+        return try {
+            Duration.Companion.parse(text)
+        } catch (_: IllegalArgumentException) {
+            throw ctxt.weirdStringException(
+                text,
+                Duration::class.java,
+                "Cannot parse duration: '$text'. Expected format like '10s', '5m', '1h', or ISO-8601 duration.",
+            )
+        }
+    }
+}
diff --git a/src/main/kotlin/org/simplemc/simpleannounce/config/DurationSerializer.kt b/src/main/kotlin/org/simplemc/simpleannounce/config/DurationSerializer.kt
new file mode 100644
index 0000000..2208dd0
--- /dev/null
+++ b/src/main/kotlin/org/simplemc/simpleannounce/config/DurationSerializer.kt
@@ -0,0 +1,12 @@
+package org.simplemc.simpleannounce.config
+
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.databind.SerializerProvider
+import com.fasterxml.jackson.databind.ser.std.StdSerializer
+import kotlin.time.Duration
+
+class DurationSerializer : StdSerializer<Duration>(Duration::class.java) {
+    override fun serialize(value: Duration, gen: JsonGenerator, serializers: SerializerProvider?) {
+        gen.writeString(value.toString())
+    }
+}
diff --git a/src/main/kotlin/org/simplemc/simpleannounce/config/SimpleAnnounceConfig.kt b/src/main/kotlin/org/simplemc/simpleannounce/config/SimpleAnnounceConfig.kt
new file mode 100644
index 0000000..35cb256
--- /dev/null
+++ b/src/main/kotlin/org/simplemc/simpleannounce/config/SimpleAnnounceConfig.kt
@@ -0,0 +1,135 @@
+package org.simplemc.simpleannounce.config
+
+import com.fasterxml.jackson.annotation.JsonAlias
+import com.fasterxml.jackson.annotation.JsonIgnore
+import com.fasterxml.jackson.annotation.JsonTypeInfo
+import com.fasterxml.jackson.annotation.JsonUnwrapped
+import org.bukkit.boss.BarColor
+import org.bukkit.boss.BarStyle
+import org.simplemc.simpleannounce.inTicks
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.seconds
+
+data class SimpleAnnounceConfig(
+    val autoReload: Duration? = null,
+    val announcements: List<AnnouncementConfig<*>>,
+) {
+    companion object {
+        private fun Duration?.checkNullZeroOrPositive(name: String) {
+            check(this == null || this == Duration.Companion.ZERO || this.isPositive()) {
+                "When set, $name must be >= 0s"
+            }
+        }
+    }
+
+    @JsonIgnore
+    val autoReloadTicks = autoReload?.inTicks
+
+    init {
+        check(autoReload == null || autoReload == Duration.Companion.ZERO || autoReload.inWholeMinutes >= 1) {
+            "When set, Auto Reload Duration must be > 1 minute"
+        }
+    }
+
+    @JsonTypeInfo(use = JsonTypeInfo.Id.SIMPLE_NAME, include = JsonTypeInfo.As.PROPERTY, property = "type")
+    sealed class AnnouncementConfig<T> {
+        abstract val random: Boolean
+        abstract val delay: Duration
+        abstract val repeat: Duration?
+        abstract val includesPermissions: List<String>
+        abstract val excludesPermissions: List<String>
+        abstract val messages: List<T>
+
+        @JsonIgnore
+        val delayTicks = delay.inTicks.toInt()
+
+        @JsonIgnore
+        val repeatTicks = repeat?.inTicks?.toInt()
+
+        init {
+            delay.checkNullZeroOrPositive("delay")
+            repeat.checkNullZeroOrPositive("repeat")
+        }
+
+        data class Chat(
+            override val random: Boolean = false,
+            override val delay: Duration = Duration.Companion.ZERO,
+            override val repeat: Duration? = null,
+            override val includesPermissions: List<String> = emptyList(),
+            override val excludesPermissions: List<String> = emptyList(),
+            @field:JsonAlias("message") override val messages: List<String>,
+        ) : AnnouncementConfig<String>()
+
+        data class Boss(
+            override val random: Boolean = false,
+            override val delay: Duration = Duration.Companion.ZERO,
+            override val repeat: Duration? = null,
+            override val includesPermissions: List<String> = emptyList(),
+            override val excludesPermissions: List<String> = emptyList(),
+            @field:JsonAlias("message") override val messages: List<BossBarMessage>,
+            @field:JsonUnwrapped val barConfig: BarConfig = BarConfig(),
+        ) : AnnouncementConfig<Boss.BossBarMessage>() {
+            data class BossBarMessage(
+                val message: String,
+                @field:JsonUnwrapped val barConfig: BarConfig? = null,
+            ) {
+                init {
+                    require(message.length <= 64) { "Boss Bar text must be <= 64 characters" }
+                }
+            }
+
+            data class BarConfig(
+                val hold: Duration = 5.seconds,
+                val color: BarColor = BarColor.PURPLE,
+                val style: BarStyle = BarStyle.SOLID,
+                val animate: Boolean = true,
+                val reverseAnimation: Boolean = false,
+            ) {
+                @JsonIgnore
+                val holdTicks = hold.inTicks
+
+                init {
+                    hold.checkNullZeroOrPositive("hold")
+                }
+            }
+        }
+
+        data class Title(
+            override val random: Boolean = false,
+            override val delay: Duration = Duration.Companion.ZERO,
+            override val repeat: Duration? = null,
+            override val includesPermissions: List<String> = emptyList(),
+            override val excludesPermissions: List<String> = emptyList(),
+            @field:JsonAlias("message") override val messages: List<TitleMessage>,
+            @field:JsonUnwrapped val titleConfig: TitleConfig = TitleConfig(),
+        ) : AnnouncementConfig<Title.TitleMessage>() {
+            data class TitleMessage(
+                val title: String,
+                val subtitle: String? = null,
+                @field:JsonUnwrapped val titleConfig: TitleConfig? = null,
+            )
+
+            data class TitleConfig(
+                val fadeIn: Duration = 500.milliseconds,
+                val stay: Duration = 5.seconds,
+                val fadeOut: Duration = 500.milliseconds,
+            ) {
+                @JsonIgnore
+                val fadeInTicks = fadeIn.inTicks.toInt()
+
+                @JsonIgnore
+                val stayTicks = stay.inTicks.toInt()
+
+                @JsonIgnore
+                val fadeOutTicks = fadeOut.inTicks.toInt()
+
+                init {
+                    fadeIn.checkNullZeroOrPositive("fadeIn")
+                    stay.checkNullZeroOrPositive("stay")
+                    fadeOut.checkNullZeroOrPositive("fadeOut")
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/kotlin/org/simplemc/simpleannounce/message/Announcement.kt b/src/main/kotlin/org/simplemc/simpleannounce/message/Announcement.kt
deleted file mode 100644
index 523e8ba..0000000
--- a/src/main/kotlin/org/simplemc/simpleannounce/message/Announcement.kt
+++ /dev/null
@@ -1,30 +0,0 @@
-package org.simplemc.simpleannounce.message
-
-import io.github.oshai.kotlinlogging.KotlinLogging
-import java.util.concurrent.atomic.AtomicInteger
-import kotlin.random.Random
-
-private val logger = KotlinLogging.logger("SimpleAnnounce Announcement")
-
-data class Announcement(
-    internal val label: String,
-    private val messages: List<String>,
-    internal val permissionIncludes: List<String>,
-    internal val permissionExcludes: List<String>,
-    internal val delay: Int,
-    internal val period: Int?,
-    private val random: Boolean,
-) {
-    private val current = AtomicInteger()
-
-    init {
-        messages.ifEmpty { throw IllegalArgumentException("Cannot create an announcement with no messages!") }
-        logger.trace { "Announcement '$label' created with ${messages.size} messages." }
-    }
-
-    fun getMessage() = when {
-        messages.size == 1 -> messages[0]
-        random -> messages[Random.nextInt(messages.size)]
-        else -> messages[current.getAndIncrement().also { if (it == messages.lastIndex) current.set(0) }]
-    }
-}
diff --git a/src/main/kotlin/org/simplemc/simpleannounce/message/sender/AnnouncementSender.kt b/src/main/kotlin/org/simplemc/simpleannounce/message/sender/AnnouncementSender.kt
deleted file mode 100644
index e5020da..0000000
--- a/src/main/kotlin/org/simplemc/simpleannounce/message/sender/AnnouncementSender.kt
+++ /dev/null
@@ -1,25 +0,0 @@
-package org.simplemc.simpleannounce.message.sender
-
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.bukkit.Bukkit
-import org.bukkit.entity.Player
-import org.bukkit.plugin.Plugin
-import org.simplemc.simpleannounce.message.Announcement
-
-private val logger = KotlinLogging.logger("SimpleAnnounce AnnouncementSender")
-
-abstract class AnnouncementSender(internal val plugin: Plugin, internal val announcement: Announcement) : Runnable {
-    init {
-        scheduleTask()
-        logger.trace { "${this::class.java.simpleName} for announcement '${announcement.label}' created!" }
-    }
-
-    private fun scheduleTask() = announcement.period?.let {
-        Bukkit.getScheduler().runTaskTimer(plugin, this, announcement.delay * 20L, announcement.period * 20L)
-    } ?: Bukkit.getScheduler().runTaskLater(plugin, this, announcement.delay * 20L)
-
-    internal fun shouldSendTo(player: Player) = !(
-        announcement.permissionIncludes.any { !player.hasPermission(it) } ||
-            announcement.permissionExcludes.any(player::hasPermission)
-        )
-}
diff --git a/src/main/kotlin/org/simplemc/simpleannounce/message/sender/BossBarSender.kt b/src/main/kotlin/org/simplemc/simpleannounce/message/sender/BossBarSender.kt
deleted file mode 100644
index 8321ed6..0000000
--- a/src/main/kotlin/org/simplemc/simpleannounce/message/sender/BossBarSender.kt
+++ /dev/null
@@ -1,51 +0,0 @@
-package org.simplemc.simpleannounce.message.sender
-
-import org.bukkit.Bukkit
-import org.bukkit.boss.BarColor
-import org.bukkit.boss.BarStyle
-import org.bukkit.boss.BossBar
-import org.bukkit.plugin.Plugin
-import org.bukkit.scheduler.BukkitTask
-import org.simplemc.simpleannounce.message.Announcement
-
-class BossBarSender(
-    plugin: Plugin,
-    announcement: Announcement,
-    holdTime: Int,
-    private val color: BarColor,
-    private val style: BarStyle,
-    private val animate: Boolean,
-    private val reverse: Boolean,
-) : AnnouncementSender(plugin, announcement) {
-
-    private val holdTicks = holdTime * 20L // convert from seconds to ticks
-
-    override fun run() {
-        // create the bar
-        val bar = Bukkit.createBossBar(announcement.getMessage(), color, style)
-        bar.progress = if (reverse) 1.0 else 0.0
-
-        // show bar to players
-        Bukkit.getOnlinePlayers().filterNotNull().filter(this::shouldSendTo).forEach(bar::addPlayer)
-        bar.isVisible = true
-
-        // set up animation
-        val animation = if (animate) {
-            Bukkit.getScheduler().runTaskTimer(plugin, updateBarProgress(bar), 0, 1L)
-        } else {
-            null
-        }
-
-        // schedule removal
-        Bukkit.getScheduler().runTaskLater(plugin, removeBar(bar, animation), holdTicks)
-    }
-
-    private fun updateBarProgress(bar: BossBar): () -> Unit = {
-        bar.progress = (bar.progress + (if (reverse) -1 else 1) * (1.0 / holdTicks)).coerceIn(0.0, 1.0)
-    }
-
-    private fun removeBar(bar: BossBar, animation: BukkitTask?): () -> Unit = {
-        bar.removeAll()
-        animation?.cancel()
-    }
-}
diff --git a/src/main/kotlin/org/simplemc/simpleannounce/message/sender/ChatSender.kt b/src/main/kotlin/org/simplemc/simpleannounce/message/sender/ChatSender.kt
deleted file mode 100644
index bc50f43..0000000
--- a/src/main/kotlin/org/simplemc/simpleannounce/message/sender/ChatSender.kt
+++ /dev/null
@@ -1,14 +0,0 @@
-package org.simplemc.simpleannounce.message.sender
-
-import org.bukkit.Bukkit
-import org.bukkit.plugin.Plugin
-import org.simplemc.simpleannounce.message.Announcement
-
-class ChatSender(plugin: Plugin, announcement: Announcement) : AnnouncementSender(plugin, announcement) {
-    override fun run() {
-        Bukkit.getOnlinePlayers()
-            .filterNotNull()
-            .filter(this::shouldSendTo)
-            .forEach { it.sendMessage(announcement.getMessage()) }
-    }
-}
diff --git a/src/main/kotlin/org/simplemc/simpleannounce/sender/AnnouncementSender.kt b/src/main/kotlin/org/simplemc/simpleannounce/sender/AnnouncementSender.kt
new file mode 100644
index 0000000..f0404a2
--- /dev/null
+++ b/src/main/kotlin/org/simplemc/simpleannounce/sender/AnnouncementSender.kt
@@ -0,0 +1,48 @@
+package org.simplemc.simpleannounce.sender
+
+import io.github.oshai.kotlinlogging.KotlinLogging
+import org.bukkit.Bukkit
+import org.bukkit.entity.Player
+import org.bukkit.plugin.Plugin
+import org.simplemc.simpleannounce.config.SimpleAnnounceConfig
+import org.simplemc.simpleannounce.inTicks
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.random.Random
+
+private val logger = KotlinLogging.logger("SimpleAnnounce AnnouncementSender")
+
+abstract class AnnouncementSender<MessageType, ConfigType : SimpleAnnounceConfig.AnnouncementConfig<MessageType>>(
+    internal val plugin: Plugin,
+    internal val announcement: ConfigType,
+) : Runnable {
+    private val currentIndex = AtomicInteger()
+    private val scheduler = Bukkit.getScheduler()
+
+    init {
+        check(announcement.messages.isNotEmpty()) { "Cannot create an announcement with no messages!" }
+        scheduleTask()
+        logger.trace {
+            "${this::class.java.simpleName} created with ${announcement.messages.size} messages (first message '${announcement.messages.firstOrNull()}'}!"
+        }
+    }
+
+    private fun scheduleTask() = announcement.repeat?.inTicks?.let { repeatTicks ->
+        scheduler.runTaskTimer(plugin, this, announcement.delay.inTicks, repeatTicks)
+    } ?: scheduler.runTaskLater(plugin, this, announcement.delay.inTicks)
+
+    internal fun shouldSendTo(player: Player): Boolean {
+        val hasAllRequiredPermissions = announcement.includesPermissions.none { !player.hasPermission(it) }
+        val hasNoExcludedPermissions = announcement.excludesPermissions.none { player.hasPermission(it) }
+        return hasAllRequiredPermissions && hasNoExcludedPermissions
+    }
+
+    internal fun getNextAnnouncement(): MessageType = when {
+        announcement.messages.size == 1 -> announcement.messages[0]
+        announcement.random -> announcement.messages[Random.nextInt(announcement.messages.size)]
+        else -> {
+            val nextIndex = currentIndex.getAndIncrement()
+            if (nextIndex == announcement.messages.lastIndex) currentIndex.set(0)
+            announcement.messages[nextIndex]
+        }
+    }
+}
diff --git a/src/main/kotlin/org/simplemc/simpleannounce/sender/BossBarSender.kt b/src/main/kotlin/org/simplemc/simpleannounce/sender/BossBarSender.kt
new file mode 100644
index 0000000..9bef14a
--- /dev/null
+++ b/src/main/kotlin/org/simplemc/simpleannounce/sender/BossBarSender.kt
@@ -0,0 +1,49 @@
+package org.simplemc.simpleannounce.sender
+
+import org.bukkit.Bukkit
+import org.bukkit.boss.BossBar
+import org.bukkit.plugin.Plugin
+import org.bukkit.scheduler.BukkitTask
+import org.simplemc.simpleannounce.config.SimpleAnnounceConfig.AnnouncementConfig.Boss
+
+class BossBarSender(
+    plugin: Plugin,
+    announcement: Boss,
+) : AnnouncementSender<Boss.BossBarMessage, Boss>(plugin, announcement) {
+    override fun run() {
+        val message = getNextAnnouncement()
+        val barConfig = message.barConfig ?: announcement.barConfig
+
+        // create the bar
+        val bar = Bukkit.createBossBar(message.message, barConfig.color, barConfig.style)
+        bar.progress = if (barConfig.reverseAnimation) 1.0 else 0.0
+
+        // show bar to players
+        Bukkit.getOnlinePlayers().filterNotNull().filter(this::shouldSendTo).forEach(bar::addPlayer)
+        bar.isVisible = true
+
+        // set up animation
+        val animation = if (barConfig.animate) {
+            Bukkit.getScheduler().runTaskTimer(plugin, updateBarProgress(bar, barConfig), 0, 1L)
+        } else {
+            null
+        }
+
+        // schedule removal
+        Bukkit.getScheduler().runTaskLater(plugin, removeBar(bar, animation), barConfig.holdTicks)
+    }
+
+    private fun updateBarProgress(bar: BossBar, config: Boss.BarConfig): () -> Unit {
+        val progressPerTick = 1.0 / config.holdTicks
+        val animationDirection = if (config.reverseAnimation) -1.0 else 1.0
+        return {
+            val newProgress = bar.progress + (animationDirection * progressPerTick)
+            bar.progress = newProgress.coerceIn(0.0, 1.0)
+        }
+    }
+
+    private fun removeBar(bar: BossBar, animation: BukkitTask?): () -> Unit = {
+        bar.removeAll()
+        animation?.cancel()
+    }
+}
diff --git a/src/main/kotlin/org/simplemc/simpleannounce/sender/ChatSender.kt b/src/main/kotlin/org/simplemc/simpleannounce/sender/ChatSender.kt
new file mode 100644
index 0000000..bfae817
--- /dev/null
+++ b/src/main/kotlin/org/simplemc/simpleannounce/sender/ChatSender.kt
@@ -0,0 +1,17 @@
+package org.simplemc.simpleannounce.sender
+
+import org.bukkit.Bukkit
+import org.bukkit.plugin.Plugin
+import org.simplemc.simpleannounce.config.SimpleAnnounceConfig.AnnouncementConfig.Chat
+
+class ChatSender(
+    plugin: Plugin,
+    announcement: Chat,
+) : AnnouncementSender<String, Chat>(plugin, announcement) {
+    override fun run() {
+        Bukkit.getOnlinePlayers()
+            .filterNotNull()
+            .filter(this::shouldSendTo)
+            .forEach { it.sendMessage(getNextAnnouncement()) }
+    }
+}
diff --git a/src/main/kotlin/org/simplemc/simpleannounce/sender/TitleSender.kt b/src/main/kotlin/org/simplemc/simpleannounce/sender/TitleSender.kt
new file mode 100644
index 0000000..5cb7862
--- /dev/null
+++ b/src/main/kotlin/org/simplemc/simpleannounce/sender/TitleSender.kt
@@ -0,0 +1,28 @@
+package org.simplemc.simpleannounce.sender
+
+import org.bukkit.Bukkit
+import org.bukkit.plugin.Plugin
+import org.simplemc.simpleannounce.config.SimpleAnnounceConfig.AnnouncementConfig.Title
+
+class TitleSender(
+    plugin: Plugin,
+    announcement: Title,
+) : AnnouncementSender<Title.TitleMessage, Title>(plugin, announcement) {
+    override fun run() {
+        val message = getNextAnnouncement()
+        val titleConfig = message.titleConfig ?: announcement.titleConfig
+
+        Bukkit.getOnlinePlayers()
+            .filterNotNull()
+            .filter(this::shouldSendTo)
+            .forEach {
+                it.sendTitle(
+                    message.title,
+                    message.subtitle,
+                    titleConfig.fadeInTicks,
+                    titleConfig.stayTicks,
+                    titleConfig.fadeOutTicks,
+                )
+            }
+    }
+}
diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml
index 88c5d95..c30eddc 100644
--- a/src/main/resources/config.yml
+++ b/src/main/resources/config.yml
@@ -1,60 +1,100 @@
 # Config nodes:
 #
-# auto-reloadconfig(int): <Time in minutes to check/reload config for message updates(0 for off)>
+# autoReload(duration, optional): <Time between automatically reloading plugin configuration, unset or 0m for off>
 #     NOTE: When config is reloaded, will reset delays for messages and cause one-time messages to resend
-# debug-mode(boolean): <Should we pring debug to server.log(true/false)?>
-#     NOTE: Look for fine and finer level log messages in server.log
-# announcements: Add announcements below to this section
-#     <message label>(String, must be unique):
-#         message(String, required) OR messages(String list, see sample config): <Message to send>
-#         random-order(boolean, optional): <if list of messages should be sent in random order>
-#         sender(String, optional): <Message Sender(chat or boss, default: chat)>
-#         bar(section, optional):
-#             hold(int, optional): <Time in sections for bar to be displayed on announce>
-#             color(String, optional): <bar color(https://hub.spigotmc.org/javadocs/spigot/org/bukkit/boss/BarColor.html)>
-#             style(String, optional): <bar style(https://hub.spigotmc.org/javadocs/spigot/org/bukkit/boss/BarStyle.html)>
-#             animate(section, optional):
-#                 enable(boolean, optional): <if bar should animate hold time>
-#                 reverse(boolean, optional): <if animation should be reversed>
-#         delay(int, optional - default 0): <Delay to send message on in seconds>
-#         repeat(int, optional): <time between repeat sendings of the message in seconds>
-#         includesperms(String list, optional):
-#         - <only send to those with this perm>
-#         - <and this one>
-#         excludesperms(String list, optional):
-#         - <don't send to those with this perm>
-#         - <and this one>
+# announcements(Announcement list): <list of announcement configurations, see below for detail>
+# config-version: **Internal use for configuration migrations, do not edit**
+#
+# -------------------------
+#
+# Announcement config nodes:
+#
+# type(Announcement type): <Type of announcement: Chat, Title, or Boss>
+# message(Message) OR messages(Message list, see sample config): <Message(s) to send>
+# random(boolean, optional): <if list of messages should be sent in random order>
+# delay(duration, optional - default 0): <Delay to send message>
+# repeat(duration, optional): <time between sending/repeating each message>
+# includesPermissions(String list, optional):
+# - <only send to those with this perm>
+# - <and this one>
+# excludesPermissions(String list, optional):
+# - <don't send to those with this perm>
+# - <and this one>
+# <additional options depending on announcement type>
+#
+# -------------------------
+#
+# Chat type:
+
+# messages(String list): [<list of messages>]
+#
+# Boss type:
+#
+# hold(duration): <Time for boss bar to be on screen>
+# color(BarColor): <Color of bar, one of PINK, BLUE, RED, GREEN, YELLOW, PURPLE, WHITE>
+# style(BarStyle): <Style of bar, one of SOLID, SEGMENTED_6, SEGMENTED_10, SEGMENTED_12, SEGMENTED_20>
+# animate(boolean): <if bar should animate over hold time>
+# reverseAnimation(boolean): <if animation should be reversed>
+# messages(BossBarMessage list):
+# - message(string): <message string>
+#   <boss bar config overrides eg hold, color, style, animate, etc...see above>
+#
+# Title type:
+#
+# fadeIn(duration): <Time it takes for title to fade in>
+# stay(duration): <Time for title to stay on screen>
+# fadeOut(duration): <Time it takes for title to fade out>
+# messages(TitleMessage list):
+# - title(string): <title string>
+#   subtitle(string): <subtitle string, appears below title slightly smaller>
+#   <title config overrides eg fadeIn, stay, fadeOut...see above>
 #
 # -------------------------
 #
 #  Note: For permissions, includes are applied first, then excludes are taken out
 
-config-version: 1
-auto-reloadconfig: 20
-debug-mode: false
+autoReload: 10m
 announcements:
-  repeating-example:
+  - type: Chat
+    delay: 30s
+    repeat: 2m
+    includesPermissions:
+      - permissions.build
+      - another.permission
+    excludesPermissions:
+      - permissions.admin
     messages:
-      - This is an automatically generated repeating message!
-    delay: 15
-    repeat: 60
-  permissions-example:
+      - hello
+      - world
+  - type: Chat
+    repeat: 1m 40s
     messages:
-      - This is another automatically generated repeating message for people with build permission!
-    delay: 30
-    repeat: 60
-    includesperms:
-    - permissions.build
-  one-time-example:
+      - abc
+      - xyz
+  - type: Title
+    repeat: 30s
     messages:
-      - This is an automatically generated one-time message!
-    delay: 45
-  message-group-example:
+      - title: Title!
+        subtitle: Subtitle!
+      - title: Title only custom durations
+        fadeIn: 100ms
+        stay: 10s
+        fadeOut: 1s
+    fadeIn: 500ms
+    stay: 5s
+    fadeOut: 500ms
+  - type: Boss
+    random: true
+    repeat: 15s
     messages:
-      - This is an automatically generated sequential message group (1 of 3)!
-      - This is an automatically generated sequential message group (2 of 3)!
-      - This is an automatically generated sequential message group (3 of 3)!
-    delay: 30
-    repeat: 30
-    sender: bossbar
-    random-order: false
+      - message: eyy
+      - message: custom bar config
+        hold: 10s
+        color: GREEN
+        style: SEGMENTED_20
+        reverseAnimation: true
+    hold: 5s
+    color: PURPLE
+    style: SOLID
+    animate: true
+config-version: 1