diff --git a/buildSrc/src/main/kotlin/DownloadJavadocsPlugin.kt b/buildSrc/src/main/kotlin/DownloadJavadocsPlugin.kt
index 2a6d376e..93af3570 100644
--- a/buildSrc/src/main/kotlin/DownloadJavadocsPlugin.kt
+++ b/buildSrc/src/main/kotlin/DownloadJavadocsPlugin.kt
@@ -22,7 +22,7 @@ private fun legacyJavadoc(url: String) = JavadocUrl(url, noframe = true)
 class DownloadJavadocsPlugin : Plugin<Project> {
     private val toDownload = mapOf(
         "8.1" to listOf(
-            javadoc("https://files.inductiveautomation.com/sdk/javadoc/ignition81/8.1.27/"),
+            javadoc("https://files.inductiveautomation.com/sdk/javadoc/ignition81/8.1.29/"),
             javadoc("https://docs.oracle.com/en/java/javase/11/docs/api/"),
             legacyJavadoc("https://www.javadoc.io/static/org.python/jython-standalone/2.7.1/")
         ),
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index adaaa721..1cc8a71c 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -33,6 +33,7 @@ flatlaf-extras = { group = "com.formdev", name = "flatlaf-extras", version.ref =
 flatlaf-jide = { group = "com.formdev", name = "flatlaf-jide-oss", version.ref = "flatlaf" }
 flatlaf-swingx = { group = "com.formdev", name = "flatlaf-swingx", version.ref = "flatlaf" }
 flatlaf-themes = { group = "com.formdev", name = "flatlaf-intellij-themes", version.ref = "flatlaf" }
+flatlaf-fonts-roboto = { group = "com.formdev", name = "flatlaf-fonts-roboto", version = "2.137"}
 svgSalamander = { group = "com.formdev", name = "svgSalamander", version = "1.1.4" }
 jide-common = { group = "com.formdev", name = "jide-oss", version = "3.7.12" }
 swingx = { group = "org.swinglabs.swingx", name = "swingx-all", version = "1.6.5-1" }
@@ -62,6 +63,7 @@ flatlaf = [
     "flatlaf-jide",
     "flatlaf-swingx",
     "flatlaf-themes",
+    "flatlaf-fonts-roboto",
 ]
 kotest = [
     "kotest-junit",
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/MainPanel.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/MainPanel.kt
index ca7568a8..10b2c798 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/MainPanel.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/MainPanel.kt
@@ -5,10 +5,13 @@ import com.formdev.flatlaf.extras.FlatAnimatedLafChange
 import com.formdev.flatlaf.extras.FlatSVGIcon
 import com.formdev.flatlaf.extras.FlatUIDefaultsInspector
 import com.formdev.flatlaf.extras.components.FlatTextArea
+import com.formdev.flatlaf.fonts.roboto.FlatRobotoFont
 import com.formdev.flatlaf.util.SystemInfo
 import io.github.inductiveautomation.kindling.core.ClipboardTool
 import io.github.inductiveautomation.kindling.core.CustomIconView
 import io.github.inductiveautomation.kindling.core.Kindling.Preferences.Advanced.Debug
+import io.github.inductiveautomation.kindling.core.Kindling.Preferences.General.ChoosableEncodings
+import io.github.inductiveautomation.kindling.core.Kindling.Preferences.General.DefaultEncoding
 import io.github.inductiveautomation.kindling.core.Kindling.Preferences.General.DefaultTool
 import io.github.inductiveautomation.kindling.core.Kindling.Preferences.General.HomeLocation
 import io.github.inductiveautomation.kindling.core.Kindling.Preferences.UI.ScaleFactor
@@ -25,9 +28,12 @@ import io.github.inductiveautomation.kindling.utils.TabStrip
 import io.github.inductiveautomation.kindling.utils.chooseFiles
 import io.github.inductiveautomation.kindling.utils.getLogger
 import io.github.inductiveautomation.kindling.utils.jFrame
+import io.github.inductiveautomation.kindling.utils.menuShortcutKeyMaskEx
+import io.github.inductiveautomation.kindling.utils.traverseChildren
 import net.miginfocom.layout.PlatformDefaults
 import net.miginfocom.layout.UnitValue
 import net.miginfocom.swing.MigLayout
+import java.awt.BorderLayout
 import java.awt.Desktop
 import java.awt.Dimension
 import java.awt.EventQueue
@@ -39,22 +45,57 @@ import java.awt.event.KeyEvent
 import java.awt.event.MouseAdapter
 import java.awt.event.MouseEvent
 import java.io.File
+import java.nio.charset.Charset
+import javax.swing.Box
 import javax.swing.JButton
+import javax.swing.JComboBox
 import javax.swing.JFileChooser
 import javax.swing.JFrame
+import javax.swing.JLabel
 import javax.swing.JMenu
 import javax.swing.JMenuBar
 import javax.swing.JPanel
 import javax.swing.KeyStroke
+import javax.swing.SwingConstants
 import javax.swing.UIManager
+import javax.swing.filechooser.FileFilter
 
-class MainPanel(empty: Boolean) : JPanel(MigLayout("ins 6, fill")) {
+class MainPanel : JPanel(MigLayout("ins 6, fill")) {
     private val fileChooser = JFileChooser(HomeLocation.currentValue.toFile()).apply {
         isMultiSelectionEnabled = true
         fileView = CustomIconView()
 
+        val encodingSelector = JComboBox(ChoosableEncodings).apply {
+            toolTipText = "Charset Encoding for Wrapper Logs"
+            selectedItem = DefaultEncoding.currentValue
+            addActionListener {
+                DefaultEncoding.currentValue = selectedItem as Charset
+            }
+            isEnabled = DefaultTool.currentValue.respectsEncoding
+        }
+
+        traverseChildren().filterIsInstance<JPanel>().last().apply {
+            add(encodingSelector, 0)
+            add(
+                JLabel("Encoding: ", SwingConstants.RIGHT).apply {
+                    verticalAlignment = SwingConstants.BOTTOM
+                },
+                0,
+            )
+        }
+
         Tool.byFilter.keys.forEach(this::addChoosableFileFilter)
         fileFilter = DefaultTool.currentValue.filter
+        addPropertyChangeListener(JFileChooser.FILE_FILTER_CHANGED_PROPERTY) { e ->
+            val relevantTool = Tool.byFilter[e.newValue as FileFilter]
+            encodingSelector.isEnabled = relevantTool?.respectsEncoding != false // null = 'all files', so enabled
+        }
+
+        addActionListener {
+            if (selectedFile != null) {
+                HomeLocation.currentValue = selectedFile.parentFile.toPath()
+            }
+        }
 
         Theme.addChangeListener {
             updateUI()
@@ -63,16 +104,30 @@ class MainPanel(empty: Boolean) : JPanel(MigLayout("ins 6, fill")) {
 
     private val openAction = Action(
         name = "Open...",
-        accelerator = KeyStroke.getKeyStroke(KeyEvent.VK_O, Toolkit.getDefaultToolkit().menuShortcutKeyMaskEx),
+        accelerator = KeyStroke.getKeyStroke(KeyEvent.VK_O, menuShortcutKeyMaskEx),
     ) {
-        fileChooser.chooseFiles(this)?.let { selectedFiles ->
+        fileChooser.chooseFiles(this@MainPanel)?.let { selectedFiles ->
             val selectedTool: Tool? = Tool.byFilter[fileChooser.fileFilter]
             openFiles(selectedFiles, selectedTool)
         }
     }
 
-    private val tabs = TabStrip()
-    private val openButton = JButton(openAction)
+    private val tabs = TabStrip().apply {
+        if (SystemInfo.isMacFullWindowContentSupported) {
+            // add padding component for MacOS window controls
+            leadingComponent = Box.createHorizontalStrut(70)
+        }
+
+        trailingComponent = JPanel(BorderLayout()).apply {
+            add(
+                JButton(openAction).apply {
+                    hideActionText = true
+                    icon = FlatSVGIcon("icons/bx-plus.svg")
+                },
+                BorderLayout.WEST,
+            )
+        }
+    }
 
     private val debugMenu = JMenu("Debug").apply {
         add(
@@ -116,7 +171,7 @@ class MainPanel(empty: Boolean) : JPanel(MigLayout("ins 6, fill")) {
                                     clipboardTool.open(clipString)
                                 }
                             } else {
-                                println("No string data found on clipboard")
+                                LOGGER.info("No string data found on clipboard")
                             }
                         },
                     )
@@ -143,13 +198,6 @@ class MainPanel(empty: Boolean) : JPanel(MigLayout("ins 6, fill")) {
      * Opens a path in a tool (blocking). In the event of any error, opens an 'Error' tab instead.
      */
     private fun openOrError(title: String, description: String, openFunction: () -> ToolPanel) {
-        synchronized(treeLock) {
-            val child = getComponent(0)
-            if (child == openButton) {
-                remove(openButton)
-                add(tabs, "dock center")
-            }
-        }
         runCatching {
             val toolPanel = openFunction()
             tabs.addTab(component = toolPanel, select = true)
@@ -199,11 +247,7 @@ class MainPanel(empty: Boolean) : JPanel(MigLayout("ins 6, fill")) {
     }
 
     init {
-        if (empty) {
-            add(openButton, "dock center")
-        } else {
-            add(tabs, "dock center")
-        }
+        add(tabs, "dock center")
 
         Debug.addChangeListener { newValue ->
             debugMenu.isVisible = newValue
@@ -217,15 +261,21 @@ class MainPanel(empty: Boolean) : JPanel(MigLayout("ins 6, fill")) {
         fun main(args: Array<String>) {
             System.setProperty("apple.awt.application.name", "Kindling")
             System.setProperty("apple.laf.useScreenMenuBar", "true")
+            System.setProperty("apple.awt.application.appearance", "system")
             System.setProperty("flatlaf.uiScale", ScaleFactor.currentValue.toString())
 
             EventQueue.invokeLater {
                 lafSetup()
 
-                jFrame("Kindling", 1280, 800) {
+                jFrame(
+                    title = "Kindling",
+                    width = 1280,
+                    height = 800,
+                    embedContentIntoTitleBar = true,
+                ) {
                     defaultCloseOperation = JFrame.EXIT_ON_CLOSE
 
-                    val mainPanel = MainPanel(args.isEmpty())
+                    val mainPanel = MainPanel()
                     add(mainPanel)
                     jMenuBar = mainPanel.menuBar
 
@@ -245,9 +295,15 @@ class MainPanel(empty: Boolean) : JPanel(MigLayout("ins 6, fill")) {
         }
 
         private fun lafSetup() {
+            FlatRobotoFont.install()
+            FlatLaf.setPreferredFontFamily(FlatRobotoFont.FAMILY)
+            FlatLaf.setPreferredLightFontFamily(FlatRobotoFont.FAMILY_LIGHT)
+            FlatLaf.setPreferredSemiboldFontFamily(FlatRobotoFont.FAMILY_SEMIBOLD)
             applyTheme(false)
 
             UIManager.getDefaults().apply {
+                put("Component.focusWidth", 0)
+                put("Component.innerfocusWidth", 1)
                 put("ScrollBar.width", 16)
                 put("TabbedPane.tabType", "card")
                 put("MenuItem.minimumIconSize", Dimension()) // https://github.com/JFormDesigner/FlatLaf/issues/328
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/cache/model/AlarmJournalData.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/cache/model/AlarmJournalData.kt
index 61b1dab5..f4bc9db2 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/cache/model/AlarmJournalData.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/cache/model/AlarmJournalData.kt
@@ -36,18 +36,15 @@ class AlarmJournalData(
 
     val body by lazy {
         data.properties.map { property ->
-            println(property.name)
             "${property.name} (${property.type.simpleName}) = ${data.getOrDefault(property)}"
         }
     }
 
-    fun toDetail(): Detail {
-        return Detail(
-            title = "Alarm Journal Data",
-            details = details,
-            body = body,
-        )
-    }
+    fun toDetail() = Detail(
+        title = "Alarm Journal Data",
+        details = details,
+        body = body,
+    )
 
     companion object {
         @JvmStatic
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/core/Detail.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/core/Detail.kt
index 48db2359..e84b6e12 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/core/Detail.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/core/Detail.kt
@@ -5,7 +5,7 @@ import io.github.inductiveautomation.kindling.core.Detail.BodyLine
 data class Detail(
     val title: String,
     val message: String? = null,
-    val details: Map<String, String> = emptyMap(),
+    val details: Map<String, String?> = emptyMap(),
     val body: List<BodyLine> = emptyList(),
 ) {
     data class BodyLine(val text: String, val link: String? = null)
@@ -14,7 +14,7 @@ data class Detail(
         operator fun invoke(
             title: String,
             message: String? = null,
-            details: Map<String, String> = emptyMap(),
+            details: Map<String, String?> = emptyMap(),
             body: List<String> = emptyList(),
         ) = Detail(
             title,
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/core/Kindling.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/core/Kindling.kt
index b095aa2f..4c87d89c 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/core/Kindling.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/core/Kindling.kt
@@ -5,6 +5,7 @@ import com.formdev.flatlaf.themes.FlatMacLightLaf
 import com.formdev.flatlaf.util.SystemInfo
 import io.github.inductiveautomation.kindling.core.Preference.Companion.PreferenceCheckbox
 import io.github.inductiveautomation.kindling.core.Preference.Companion.preference
+import io.github.inductiveautomation.kindling.utils.CharsetSerializer
 import io.github.inductiveautomation.kindling.utils.PathSerializer
 import io.github.inductiveautomation.kindling.utils.PathSerializer.serializedForm
 import io.github.inductiveautomation.kindling.utils.ThemeSerializer
@@ -22,6 +23,7 @@ import kotlinx.serialization.json.encodeToStream
 import org.jdesktop.swingx.JXTextField
 import java.awt.Image
 import java.awt.Toolkit
+import java.nio.charset.Charset
 import java.nio.file.Path
 import java.util.Vector
 import javax.swing.JComboBox
@@ -37,13 +39,15 @@ import kotlin.io.path.outputStream
 import kotlin.time.Duration.Companion.seconds
 import io.github.inductiveautomation.kindling.core.Theme.Companion as KindlingTheme
 
-object Kindling {
+data object Kindling {
     val frameIcon: Image = Toolkit.getDefaultToolkit().getImage(Kindling::class.java.getResource("/icons/kindling.png"))
 
-    object Preferences {
-        object General : PreferenceCategory {
+    const val SECONDARY_ACTION_ICON_SCALE = 0.75F
+
+    data object Preferences {
+        data object General : PreferenceCategory {
             val HomeLocation: Preference<Path> = preference(
-                name = "Home Location",
+                name = "Browse Location",
                 description = "The default path to start looking for files.",
                 default = Path(System.getProperty("user.home"), "Downloads"),
                 serializer = PathSerializer,
@@ -67,7 +71,7 @@ object Kindling {
             )
 
             val DefaultTool: Preference<Tool> = preference(
-                "Default Tool",
+                name = "Default Tool",
                 description = "The default tool to use when invoking the file selector",
                 default = Tool.tools.first(),
                 serializer = ToolSerializer,
@@ -95,6 +99,33 @@ object Kindling {
                 },
             )
 
+            val ChoosableEncodings = arrayOf(
+                Charsets.UTF_8,
+                Charsets.ISO_8859_1,
+                Charsets.US_ASCII,
+            )
+
+            val DefaultEncoding: Preference<Charset> = preference(
+                name = "Encoding",
+                description = "The default encoding to use when loading text files",
+                default = if (SystemInfo.isWindows) Charsets.ISO_8859_1 else Charsets.UTF_8,
+                serializer = CharsetSerializer,
+                editor = {
+                    JComboBox(ChoosableEncodings).apply {
+                        selectedItem = currentValue
+
+                        configureCellRenderer { _, value, _, _, _ ->
+                            text = value?.displayName()
+                            toolTipText = value?.displayName()
+                        }
+
+                        addActionListener {
+                            currentValue = selectedItem as Charset
+                        }
+                    }
+                },
+            )
+
             val ShowFullLoggerNames: Preference<Boolean> = preference(
                 name = "Logger Names",
                 default = false,
@@ -112,10 +143,11 @@ object Kindling {
             )
 
             override val displayName: String = "General"
+            override val key: String = "general"
             override val preferences: List<Preference<*>> = listOf(HomeLocation, DefaultTool, ShowFullLoggerNames, UseHyperlinks)
         }
 
-        object UI : PreferenceCategory {
+        data object UI : PreferenceCategory {
             val Theme: Preference<Theme> = preference(
                 name = "Theme",
                 default = KindlingTheme.themes.getValue(if (SystemInfo.isMacOS) FlatMacLightLaf.NAME else FlatLightLaf.NAME),
@@ -145,10 +177,11 @@ object Kindling {
             )
 
             override val displayName: String = "UI"
+            override val key: String = "ui"
             override val preferences: List<Preference<*>> = listOf(Theme, ScaleFactor)
         }
 
-        object Advanced : PreferenceCategory {
+        data object Advanced : PreferenceCategory {
             val Debug: Preference<Boolean> = preference(
                 name = "Debug Mode",
                 description = null,
@@ -163,7 +196,7 @@ object Kindling {
                 default = LinkHandlingStrategy.OpenInBrowser,
                 serializer = LinkHandlingStrategy.serializer(),
                 editor = {
-                    JComboBox(LinkHandlingStrategy.values()).apply {
+                    JComboBox(Vector(LinkHandlingStrategy.entries)).apply {
                         selectedItem = currentValue
 
                         configureCellRenderer { _, value, _, _, _ ->
@@ -178,6 +211,7 @@ object Kindling {
             )
 
             override val displayName: String = "Advanced"
+            override val key: String = "advanced"
             override val preferences: List<Preference<*>> = listOf(Debug, HyperlinkStrategy)
         }
 
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/core/Preferences.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/core/Preferences.kt
index 2fc431b9..08dbcb44 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/core/Preferences.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/core/Preferences.kt
@@ -23,7 +23,6 @@ import javax.swing.border.MatteBorder
 interface PreferenceCategory {
     val displayName: String
     val key: String
-        get() = displayName.lowercase().filter(Char::isJavaIdentifierStart)
 
     val preferences: List<Preference<*>>
 }
@@ -35,7 +34,7 @@ class Preference<T : Any>(
     val requiresRestart: Boolean = false,
     private val default: T,
     val serializer: KSerializer<T>,
-    createEditor: Preference<T>.() -> JComponent,
+    createEditor: (Preference<T>.() -> JComponent)?,
 ) {
     val key: String = name.lowercase().filter(Char::isJavaIdentifierStart)
 
@@ -54,7 +53,7 @@ class Preference<T : Any>(
         listeners.add(listener)
     }
 
-    val editor: JComponent by lazy { createEditor(this) }
+    val editor: JComponent? by lazy { createEditor?.invoke(this) }
 
     companion object {
         @Suppress("FunctionName")
@@ -67,13 +66,23 @@ class Preference<T : Any>(
             }
         }
 
+        /**
+         * Creates a new [Preference] instance, automatically contained within the current [PreferenceCategory].
+         *
+         * [description] is optional, but should be provided or set on the editor
+         * component (e.g. [PreferenceCheckbox]).
+         *
+         * [serializer] can be omitted if the type is natively serializable, but is otherwise required.
+         *
+         * [editor] should return null if this is not a 'user-facing' preference.
+         */
         inline fun <reified T : Any> PreferenceCategory.preference(
             name: String,
             description: String? = null,
             requiresRestart: Boolean = false,
             default: T,
             serializer: KSerializer<T> = serializer(),
-            noinline editor: Preference<T>.() -> JComponent,
+            noinline editor: (Preference<T>.() -> JComponent)?,
         ): Preference<T> = Preference(
             name = name,
             category = this,
@@ -109,20 +118,23 @@ val preferencesEditor by lazy {
                                 isCollapsed = category.displayName == "Advanced"
 
                                 for (preference in category.preferences) {
-                                    add(
-                                        StyledLabel {
-                                            add(preference.name, Font.BOLD)
-                                            if (preference.requiresRestart) {
-                                                add(" Requires restart", "superscript")
-                                            }
-                                            if (preference.description != null) {
-                                                add("\n")
-                                                add(preference.description)
-                                            }
-                                        },
-                                        "grow, wrap, gapy 0",
-                                    )
-                                    add(preference.editor, "grow, wrap, gapy 0")
+                                    val editor = preference.editor
+                                    if (editor != null) {
+                                        add(
+                                            StyledLabel {
+                                                add(preference.name, Font.BOLD)
+                                                if (preference.requiresRestart) {
+                                                    add(" Requires restart", "superscript")
+                                                }
+                                                if (preference.description != null) {
+                                                    add("\n")
+                                                    add(preference.description)
+                                                }
+                                            },
+                                            "grow, wrap, gapy 0",
+                                        )
+                                        add(editor, "grow, wrap, gapy 0")
+                                    }
                                 }
                             }
                             add(categoryPane)
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/core/Tool.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/core/Tool.kt
index 35e5ebc5..e86a10c1 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/core/Tool.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/core/Tool.kt
@@ -17,6 +17,8 @@ interface Tool {
     val description: String
     val icon: FlatSVGIcon
     val extensions: List<String>
+    val respectsEncoding: Boolean
+        get() = false
 
     fun open(path: Path): ToolPanel
 
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/core/ToolPanel.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/core/ToolPanel.kt
index 32b10028..b141c6f4 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/core/ToolPanel.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/core/ToolPanel.kt
@@ -29,7 +29,7 @@ abstract class ToolPanel(
 
     protected fun exportMenu(defaultFileName: String = "", modelSupplier: () -> TableModel): JMenu =
         JMenu("Export").apply {
-            for (format in ExportFormat.values()) {
+            for (format in ExportFormat.entries) {
                 add(
                     Action("Export as ${format.extension.uppercase()}") {
                         exportFileChooser.apply {
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/idb/IdbView.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/idb/IdbView.kt
index a13d8cb8..a6b59e10 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/idb/IdbView.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/idb/IdbView.kt
@@ -1,13 +1,14 @@
 package io.github.inductiveautomation.kindling.idb
 
 import com.formdev.flatlaf.extras.FlatSVGIcon
+import com.formdev.flatlaf.extras.components.FlatTabbedPane.TabType
 import io.github.inductiveautomation.kindling.core.Tool
 import io.github.inductiveautomation.kindling.core.ToolPanel
 import io.github.inductiveautomation.kindling.idb.generic.GenericView
 import io.github.inductiveautomation.kindling.idb.metrics.MetricsView
-import io.github.inductiveautomation.kindling.log.Level
 import io.github.inductiveautomation.kindling.log.LogPanel
-import io.github.inductiveautomation.kindling.log.SystemLogsEvent
+import io.github.inductiveautomation.kindling.log.MDC
+import io.github.inductiveautomation.kindling.log.SystemLogEvent
 import io.github.inductiveautomation.kindling.utils.SQLiteConnection
 import io.github.inductiveautomation.kindling.utils.TabStrip
 import io.github.inductiveautomation.kindling.utils.toList
@@ -26,6 +27,9 @@ class IdbView(val path: Path) : ToolPanel() {
     private val tabs = TabStrip().apply {
         trailingComponent = null
         isTabsClosable = false
+        tabType = TabType.underlined
+        tabHeight = 16
+        isHideTabAreaWithOneTab = true
     }
 
     init {
@@ -40,7 +44,7 @@ class IdbView(val path: Path) : ToolPanel() {
         )
 
         var addedTabs = 0
-        for (tool in IdbTool.values()) {
+        for (tool in IdbTool.entries) {
             if (tool.supports(tables)) {
                 tabs.addLazyTab(
                     tabName = tool.name,
@@ -91,7 +95,7 @@ enum class IdbTool {
                     )
                 }.groupBy(keySelector = { it.first }, valueTransform = { it.second })
 
-            val mdcKeys: Map<Int, Map<String, String>> = connection.prepareStatement(
+            val mdcKeys: Map<Int, List<MDC>> = connection.prepareStatement(
                 //language=sql
                 """
                 SELECT 
@@ -104,17 +108,17 @@ enum class IdbTool {
                     event_id
                 """.trimIndent(),
             ).executeQuery()
-                .toList { resultSet ->
-                    Triple(
-                        resultSet.getInt("event_id"),
-                        resultSet.getString("mapped_key"),
-                        resultSet.getString("mapped_value"),
-                    )
-                }.groupingBy { it.first }
-                .aggregateTo(mutableMapOf<Int, MutableMap<String, String>>()) { _, accumulator, element, _ ->
-                    val acc = accumulator ?: mutableMapOf()
-                    acc[element.second] = element.third ?: "null"
-                    acc
+                .use { resultSet ->
+                    buildMap<Int, MutableList<MDC>> {
+                        while (resultSet.next()) {
+                            val key = resultSet.getInt("event_id")
+                            val valueList = getOrPut(key) { mutableListOf() }
+                            valueList += MDC(
+                                resultSet.getString("mapped_key"),
+                                resultSet.getString("mapped_value"),
+                            )
+                        }
+                    }
                 }
 
             val events = connection.prepareStatement(
@@ -130,21 +134,22 @@ enum class IdbTool {
                 FROM 
                     logging_event
                 ORDER BY
-                    event_id
+                    timestmp
                 """.trimIndent(),
             ).executeQuery()
                 .toList { resultSet ->
                     val eventId = resultSet.getInt("event_id")
-                    SystemLogsEvent(
+                    SystemLogEvent(
                         timestamp = Instant.ofEpochMilli(resultSet.getLong("timestmp")),
                         message = resultSet.getString("formatted_message"),
                         logger = resultSet.getString("logger_name"),
                         thread = resultSet.getString("thread_name"),
-                        level = Level.valueOf(resultSet.getString("level_string")),
+                        level = enumValueOf(resultSet.getString("level_string")),
                         mdc = mdcKeys[eventId].orEmpty(),
                         stacktrace = stackTraces[eventId].orEmpty(),
                     )
                 }
+
             return LogPanel(events)
         }
     },
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/idb/generic/DBMetaDataTree.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/idb/generic/DBMetaDataTree.kt
index 85edcd5e..d389b6c7 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/idb/generic/DBMetaDataTree.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/idb/generic/DBMetaDataTree.kt
@@ -4,6 +4,7 @@ import com.formdev.flatlaf.extras.FlatSVGIcon
 import com.formdev.flatlaf.extras.components.FlatTree
 import com.jidesoft.swing.StyledLabelBuilder
 import com.jidesoft.swing.TreeSearchable
+import io.github.inductiveautomation.kindling.core.Kindling.SECONDARY_ACTION_ICON_SCALE
 import io.github.inductiveautomation.kindling.utils.derive
 import io.github.inductiveautomation.kindling.utils.treeCellRenderer
 import java.awt.Font
@@ -65,10 +66,10 @@ class DBMetaDataTree(treeModel: TreeModel) : FlatTree() {
     }
 
     companion object {
-        private val TABLE_ICON = FlatSVGIcon("icons/bx-table.svg").derive(0.75F)
+        private val TABLE_ICON = FlatSVGIcon("icons/bx-table.svg").derive(SECONDARY_ACTION_ICON_SCALE)
         private val TABLE_ICON_SELECTED = TABLE_ICON.derive { UIManager.getColor("Tree.selectionForeground") }
 
-        private val COLUMN_ICON = FlatSVGIcon("icons/bx-column.svg").derive(0.75F)
+        private val COLUMN_ICON = FlatSVGIcon("icons/bx-column.svg").derive(SECONDARY_ACTION_ICON_SCALE)
         private val COLUMN_ICON_SELECTED = COLUMN_ICON.derive { UIManager.getColor("Tree.selectionForeground") }
     }
 }
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/idb/generic/GenericView.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/idb/generic/GenericView.kt
index 3431b125..62a42fea 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/idb/generic/GenericView.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/idb/generic/GenericView.kt
@@ -5,10 +5,10 @@ import io.github.inductiveautomation.kindling.utils.Action
 import io.github.inductiveautomation.kindling.utils.FlatScrollPane
 import io.github.inductiveautomation.kindling.utils.attachPopupMenu
 import io.github.inductiveautomation.kindling.utils.javaType
+import io.github.inductiveautomation.kindling.utils.menuShortcutKeyMaskEx
 import io.github.inductiveautomation.kindling.utils.toList
 import net.miginfocom.swing.MigLayout
 import java.awt.Dimension
-import java.awt.Toolkit
 import java.awt.event.KeyEvent
 import java.sql.Connection
 import java.sql.JDBCType
@@ -118,7 +118,7 @@ class GenericView(connection: Connection) : ToolPanel("ins 0, fill, hidemode 3")
     private val results = ResultsPanel()
 
     init {
-        val ctrlEnter = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, Toolkit.getDefaultToolkit().menuShortcutKeyMaskEx)
+        val ctrlEnter = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, menuShortcutKeyMaskEx)
         getInputMap(WHEN_IN_FOCUSED_WINDOW).put(ctrlEnter, "execute")
         actionMap.put("execute", execute)
 
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/internal/DetailsIcon.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/internal/DetailsIcon.kt
index e9a6729a..d9b43541 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/internal/DetailsIcon.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/internal/DetailsIcon.kt
@@ -1,6 +1,7 @@
 package io.github.inductiveautomation.kindling.internal
 
 import com.formdev.flatlaf.extras.FlatSVGIcon
+import io.github.inductiveautomation.kindling.core.Kindling.SECONDARY_ACTION_ICON_SCALE
 import org.jdesktop.swingx.JXTable
 import org.jdesktop.swingx.decorator.HighlighterFactory
 import java.awt.event.MouseAdapter
@@ -41,6 +42,6 @@ class DetailsIcon(details: Map<String, String>) : JLabel(detailsIcon) {
     }
 
     companion object {
-        private val detailsIcon = FlatSVGIcon("icons/bx-search.svg").derive(0.75F)
+        private val detailsIcon = FlatSVGIcon("icons/bx-search.svg").derive(SECONDARY_ACTION_ICON_SCALE)
     }
 }
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/log/DurationUnit.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/log/DurationUnit.kt
new file mode 100644
index 00000000..45814d1a
--- /dev/null
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/log/DurationUnit.kt
@@ -0,0 +1,33 @@
+package io.github.inductiveautomation.kindling.log
+
+import java.time.Duration
+import java.time.temporal.Temporal
+import java.time.temporal.TemporalUnit
+
+// Credit to https://stackoverflow.com/a/66203968
+class DurationUnit(private val duration: Duration) : TemporalUnit {
+    init {
+        require(!(duration.isZero || duration.isNegative)) { "Duration may not be zero or negative" }
+    }
+
+    override fun getDuration(): Duration = duration
+    override fun isDurationEstimated(): Boolean = duration.seconds >= SECONDS_PER_DAY
+    override fun isDateBased(): Boolean = duration.nano == 0 && duration.seconds % SECONDS_PER_DAY == 0L
+    override fun isTimeBased(): Boolean = duration.seconds < SECONDS_PER_DAY && NANOS_PER_DAY % duration.toNanos() == 0L
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <R : Temporal?> addTo(temporal: R, amount: Long): R =
+        duration.multipliedBy(amount).addTo(temporal) as R
+
+    override fun between(temporal1Inclusive: Temporal, temporal2Exclusive: Temporal): Long {
+        return Duration.between(temporal1Inclusive, temporal2Exclusive).dividedBy(duration)
+    }
+
+    override fun toString(): String = duration.toString()
+
+    companion object {
+        private const val SECONDS_PER_DAY = 86_400
+        private const val NANOS_PER_SECOND = 1_000_000_000L
+        private const val NANOS_PER_DAY = NANOS_PER_SECOND * SECONDS_PER_DAY
+    }
+}
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/log/LevelPanel.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/log/LevelPanel.kt
new file mode 100644
index 00000000..b4373f25
--- /dev/null
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/log/LevelPanel.kt
@@ -0,0 +1,57 @@
+package io.github.inductiveautomation.kindling.log
+
+import io.github.inductiveautomation.kindling.utils.Action
+import io.github.inductiveautomation.kindling.utils.Column
+import io.github.inductiveautomation.kindling.utils.FilterList
+import io.github.inductiveautomation.kindling.utils.FilterModel
+import io.github.inductiveautomation.kindling.utils.FlatScrollPane
+import io.github.inductiveautomation.kindling.utils.add
+import io.github.inductiveautomation.kindling.utils.getAll
+import javax.swing.JComponent
+import javax.swing.JPopupMenu
+import javax.swing.event.EventListenerList
+
+internal class LevelPanel(rawData: List<LogEvent>) : LogFilterPanel {
+    private val filterList: FilterList = FilterList()
+    override val component: JComponent = FlatScrollPane(filterList)
+
+    private val listenerList = EventListenerList()
+
+    init {
+        filterList.setModel(FilterModel(rawData.groupingBy { it.level?.name }.eachCount()))
+        filterList.selectAll()
+
+        filterList.checkBoxListSelectionModel.addListSelectionListener { e ->
+            if (!e.valueIsAdjusting) {
+                listenerList.getAll<FilterChangeListener>().forEach(FilterChangeListener::filterChanged)
+            }
+        }
+    }
+
+    override val tabName: String = "Level"
+    override fun isFilterApplied() = filterList.checkBoxListSelectedValues.size != filterList.model.size - 1
+    override fun filter(event: LogEvent): Boolean = event.level?.name in filterList.checkBoxListSelectedValues
+    override fun addFilterChangeListener(listener: FilterChangeListener) {
+        listenerList.add(listener)
+    }
+
+    override fun customizePopupMenu(menu: JPopupMenu, column: Column<out LogEvent, *>, event: LogEvent) {
+        val level = event.level
+        if ((column == WrapperLogColumns.Level || column == SystemLogColumns.Level) && level != null) {
+            val levelIndex = filterList.model.indexOf(level.name)
+            menu.add(
+                Action("Show only $level events") {
+                    filterList.checkBoxListSelectedIndex = levelIndex
+                    filterList.ensureIndexIsVisible(levelIndex)
+                },
+            )
+            menu.add(
+                Action("Exclude $level events") {
+                    filterList.removeCheckBoxListSelectedIndex(levelIndex)
+                },
+            )
+        }
+    }
+
+    override fun reset() = filterList.selectAll()
+}
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/log/LogPanel.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/log/LogPanel.kt
index e73d826d..a3a495cc 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/log/LogPanel.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/log/LogPanel.kt
@@ -1,27 +1,34 @@
 package io.github.inductiveautomation.kindling.log
 
+import com.formdev.flatlaf.extras.components.FlatTabbedPane
 import com.formdev.flatlaf.ui.FlatScrollBarUI
 import io.github.inductiveautomation.kindling.core.Detail.BodyLine
 import io.github.inductiveautomation.kindling.core.DetailsPane
+import io.github.inductiveautomation.kindling.core.Kindling.Preferences.Advanced.Debug
 import io.github.inductiveautomation.kindling.core.Kindling.Preferences.Advanced.HyperlinkStrategy
 import io.github.inductiveautomation.kindling.core.Kindling.Preferences.General.ShowFullLoggerNames
 import io.github.inductiveautomation.kindling.core.Kindling.Preferences.General.UseHyperlinks
 import io.github.inductiveautomation.kindling.core.LinkHandlingStrategy
+import io.github.inductiveautomation.kindling.core.ToolOpeningException
 import io.github.inductiveautomation.kindling.core.ToolPanel
-import io.github.inductiveautomation.kindling.log.LogViewer.SelectedTimeZone
 import io.github.inductiveautomation.kindling.log.LogViewer.ShowDensity
+import io.github.inductiveautomation.kindling.log.LogViewer.TimeStampFormatter
+import io.github.inductiveautomation.kindling.utils.Action
+import io.github.inductiveautomation.kindling.utils.Column
 import io.github.inductiveautomation.kindling.utils.EDT_SCOPE
 import io.github.inductiveautomation.kindling.utils.FlatScrollPane
 import io.github.inductiveautomation.kindling.utils.MajorVersion
 import io.github.inductiveautomation.kindling.utils.ReifiedJXTable
+import io.github.inductiveautomation.kindling.utils.attachPopupMenu
 import io.github.inductiveautomation.kindling.utils.configureCellRenderer
-import io.github.inductiveautomation.kindling.utils.getValue
+import io.github.inductiveautomation.kindling.utils.isSortedBy
 import io.github.inductiveautomation.kindling.utils.toBodyLine
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import net.miginfocom.swing.MigLayout
 import org.jdesktop.swingx.JXSearchField
+import org.jdesktop.swingx.table.ColumnControlButton
 import java.awt.Dimension
 import java.awt.Graphics
 import java.awt.Graphics2D
@@ -30,15 +37,16 @@ import java.awt.RenderingHints
 import java.awt.geom.AffineTransform
 import java.time.Duration
 import java.time.Instant
-import java.time.ZoneId
-import java.time.format.DateTimeFormatter
-import java.time.temporal.Temporal
-import java.time.temporal.TemporalUnit
+import java.util.EventListener
+import java.util.Vector
+import javax.swing.AbstractAction
 import javax.swing.Icon
+import javax.swing.JCheckBox
 import javax.swing.JComboBox
 import javax.swing.JComponent
 import javax.swing.JLabel
 import javax.swing.JPanel
+import javax.swing.JPopupMenu
 import javax.swing.JScrollBar
 import javax.swing.JSplitPane
 import javax.swing.ListSelectionModel
@@ -50,21 +58,36 @@ import kotlin.properties.Delegates
 import io.github.inductiveautomation.kindling.core.Detail as DetailEvent
 
 class LogPanel(
+    /**
+     * Pass a **sorted** list of LogEvents, in ascending order.
+     */
     private val rawData: List<LogEvent>,
 ) : ToolPanel("ins 0, fill, hidemode 3") {
-    private val totalRows: Int = rawData.size
+    init {
+        if (rawData.isEmpty()) {
+            throw ToolOpeningException("Opening an empty log file is pointless")
+        }
+        if (!rawData.isSortedBy(LogEvent::timestamp)) {
+            throw ToolOpeningException("Input data must be sorted by timestamp, ascending")
+        }
+    }
 
-    var dateFormatter: DateTimeFormatter = DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm:ss:SSS")
-        .withZone(ZoneId.systemDefault())
+    private val totalRows: Int = rawData.size
 
     private val densityDisplay = GroupingScrollBar()
 
-    val header = Header(totalRows)
+    private val header = Header(totalRows)
+
+    private val columnList = if (rawData.first() is SystemLogEvent) {
+        SystemLogColumns
+    } else {
+        WrapperLogColumns
+    }
 
     val table = run {
         val initialModel = createModel(rawData)
-        ReifiedJXTable(initialModel, initialModel.columns).apply {
-            setSortOrder("Timestamp", SortOrder.ASCENDING)
+        ReifiedJXTable(initialModel, columnList).apply {
+            setSortOrder(columnList[columnList.Timestamp], SortOrder.ASCENDING)
         }
     }
 
@@ -72,15 +95,16 @@ class LogPanel(
         verticalScrollBar = densityDisplay
     }
 
+    private val sidebar = Sidebar(rawData)
+
     private val details = DetailsPane()
-    private val sidebar = LoggerNamesPanel(rawData)
 
-    private val filters: List<(LogEvent) -> Boolean> = buildList {
+    private val filters: List<LogFilter> = buildList {
+        for (panel in sidebar.filterPanels) {
+            add(panel)
+        }
         add { event ->
-            event.logger in sidebar.list.checkBoxListSelectedIndices
-                .map { sidebar.list.model.getElementAt(it) }
-                .filterIsInstance<LoggerName>()
-                .mapTo(mutableSetOf()) { it.name }
+            !header.showOnlyMarked.selected || event.marked
         }
         add { event ->
             val text = header.search.text
@@ -88,17 +112,12 @@ class LogPanel(
                 true
             } else {
                 when (event) {
-                    is SystemLogsEvent -> {
-                        text in event.message ||
-                            event.logger.contains(text, ignoreCase = true) ||
-                            event.thread.contains(text, ignoreCase = true) ||
-                            event.stacktrace.any { stacktrace -> stacktrace.contains(text, ignoreCase = true) }
+                    is SystemLogEvent -> {
+                        text in event.message || event.logger.contains(text, ignoreCase = true) || event.thread.contains(text, ignoreCase = true) || event.stacktrace.any { stacktrace -> stacktrace.contains(text, ignoreCase = true) }
                     }
 
                     is WrapperLogEvent -> {
-                        text in event.message ||
-                            event.logger.contains(text, ignoreCase = true) ||
-                            event.stacktrace.any { stacktrace -> stacktrace.contains(text, ignoreCase = true) }
+                        text in event.message || event.logger.contains(text, ignoreCase = true) || event.stacktrace.any { stacktrace -> stacktrace.contains(text, ignoreCase = true) }
                     }
                 }
             }
@@ -107,9 +126,19 @@ class LogPanel(
 
     private fun updateData() {
         BACKGROUND.launch {
-            val filteredData = rawData.filter { event ->
-                filters.all { filter -> filter(event) }
+            val filteredData = if (Debug.currentValue) {
+                // use a less efficient, but more debuggable, filtering sequence
+                filters.fold(rawData) { acc, logFilter ->
+                    acc.filter(logFilter::filter).also {
+                        println("${it.size} left after $logFilter")
+                    }
+                }
+            } else {
+                rawData.filter { event ->
+                    filters.all { filter -> filter.filter(event) }
+                }
             }
+
             EDT_SCOPE.launch {
                 table.model = createModel(filteredData)
             }
@@ -117,12 +146,13 @@ class LogPanel(
     }
 
     @Suppress("UNCHECKED_CAST")
-    private fun createModel(rawData: List<LogEvent>) = when (rawData.firstOrNull()) {
-        is WrapperLogEvent -> LogsModel(rawData as List<WrapperLogEvent>, WrapperLogColumns(this))
-        is SystemLogsEvent -> LogsModel(rawData as List<SystemLogsEvent>, SystemLogsColumns(this))
-        else -> LogsModel(rawData as List<WrapperLogEvent>, WrapperLogColumns(this))
+    private fun createModel(rawData: List<LogEvent>): LogsModel<out LogEvent> = when (columnList) {
+        is WrapperLogColumns -> LogsModel(rawData as List<WrapperLogEvent>, columnList)
+        is SystemLogColumns -> LogsModel(rawData as List<SystemLogEvent>, columnList)
     }
 
+    override val icon: Icon? = null
+
     init {
         add(header, "wrap, growx, spanx 2")
         add(
@@ -137,82 +167,132 @@ class LogPanel(
                     resizeWeight = 0.6
                 },
             ).apply {
+                isOneTouchExpandable = true
                 resizeWeight = 0.1
             },
             "push, grow",
         )
 
-        table.selectionModel.addListSelectionListener { selectionEvent ->
-            if (!selectionEvent.valueIsAdjusting) {
-                table.selectionModel.updateDetails()
+        table.apply {
+            selectionModel.addListSelectionListener { selectionEvent ->
+                if (!selectionEvent.valueIsAdjusting) {
+                    selectionModel.updateDetails()
+                }
+            }
+            addPropertyChangeListener("model") {
+                header.displayedRows = model.rowCount
             }
-        }
-
-        table.addPropertyChangeListener("model") {
-            header.displayedRows = table.model.rowCount
-        }
 
-        sidebar.list.checkBoxListSelectionModel.addListSelectionListener {
-            if (!it.valueIsAdjusting) {
-                updateData()
+            val clearAllMarks = Action("Clear all marks") {
+                model.markRows { false }
             }
-        }
+            actionMap.put(
+                "${ColumnControlButton.COLUMN_CONTROL_MARKER}.clearAllMarks",
+                clearAllMarks,
+            )
+            attachPopupMenu { mouseEvent ->
+                val rowAtPoint = rowAtPoint(mouseEvent.point)
+                if (rowAtPoint != -1) {
+                    addRowSelectionInterval(rowAtPoint, rowAtPoint)
+                }
+                val colAtPoint = columnAtPoint(mouseEvent.point)
+                if (colAtPoint != -1) {
+                    JPopupMenu().apply {
+                        val column = model.columns[convertColumnIndexToModel(colAtPoint)]
+                        val event = model[convertRowIndexToModel(rowAtPoint)]
+                        for (filterPanel in sidebar.filterPanels) {
+                            filterPanel.customizePopupMenu(this, column, event)
+                        }
 
-        header.search.addActionListener { updateData() }
+                        if (colAtPoint == model.markIndex) {
+                            add(clearAllMarks)
+                        }
 
-        header.version.addActionListener {
-            table.selectionModel.updateDetails()
+                        if (column == SystemLogColumns.Message || column == WrapperLogColumns.Message) {
+                            add(
+                                Action("Mark all with same message") {
+                                    model.markRows { row ->
+                                        (row.message == event.message).takeIf { it }
+                                    }
+                                },
+                            )
+                        }
+
+                        if (event.stacktrace.isNotEmpty()) {
+                            add(
+                                Action("Mark all with same stacktrace") {
+                                    model.markRows { row ->
+                                        (row.stacktrace == event.stacktrace).takeIf { it }
+                                    }
+                                },
+                            )
+                        }
+
+                        if (column == SystemLogColumns.Thread && event is SystemLogEvent) {
+                            add(
+                                Action("Mark all ${event.thread} events") {
+                                    model.markRows { row ->
+                                        ((row as SystemLogEvent).thread == event.thread).takeIf { it }
+                                    }
+                                },
+                            )
+                        }
+                    }.takeIf { it.componentCount > 0 }
+                } else {
+                    null
+                }
+            }
         }
 
-        SelectedTimeZone.addChangeListener { zoneId ->
-            dateFormatter = dateFormatter.withZone(zoneId)
-            table.model.fireTableDataChanged()
+        header.apply {
+            search.addActionListener {
+                updateData()
+            }
+            version.addActionListener {
+                table.selectionModel.updateDetails()
+            }
+            showOnlyMarked.addPropertyChangeListener { e ->
+                if (e.propertyName == AbstractAction.SELECTED_KEY) {
+                    updateData()
+                }
+            }
         }
 
-        ShowFullLoggerNames.addChangeListener { newValue ->
+        ShowFullLoggerNames.addChangeListener {
             table.model.fireTableDataChanged()
-            sidebar.list.isShowFullLoggerName = newValue
         }
 
         HyperlinkStrategy.addChangeListener {
             // if the link strategy changes, we need to rebuild all the hyperlinks
             table.selectionModel.updateDetails()
         }
+
+        LogViewer.SelectedTimeZone.addChangeListener {
+            table.model.fireTableDataChanged()
+        }
     }
 
     private fun ListSelectionModel.updateDetails() {
-        details.events = selectedIndices
-            .filter { isSelectedIndex(it) }
-            .map { table.convertRowIndexToModel(it) }
-            .map { row -> table.model[row] }
-            .map { event ->
-                when (event) {
-                    is SystemLogsEvent -> DetailEvent(
-                        title = "${dateFormatter.format(event.timestamp)} ${event.thread}",
-                        message = event.message,
-                        body = event.stacktrace.map { element ->
-                            if (UseHyperlinks.currentValue) {
-                                element.toBodyLine((header.version.selectedItem as MajorVersion).version + ".0")
-                            } else {
-                                BodyLine(element)
-                            }
-                        },
-                        details = event.mdc,
-                    )
-
-                    is WrapperLogEvent -> DetailEvent(
-                        title = dateFormatter.format(event.timestamp),
-                        message = event.message,
-                        body = event.stacktrace.map { element ->
-                            if (UseHyperlinks.currentValue) {
-                                element.toBodyLine((header.version.selectedItem as MajorVersion).version + ".0")
-                            } else {
-                                BodyLine(element)
-                            }
-                        },
-                    )
-                }
-            }
+        details.events = selectedIndices.filter { isSelectedIndex(it) }.map { table.convertRowIndexToModel(it) }.map { row -> table.model[row] }.map { event ->
+            DetailEvent(
+                title = when (event) {
+                    is SystemLogEvent -> "${TimeStampFormatter.format(event.timestamp)} ${event.thread}"
+                    else -> TimeStampFormatter.format(event.timestamp)
+                },
+                message = event.message,
+                body = event.stacktrace.map { element ->
+                    if (UseHyperlinks.currentValue) {
+                        element.toBodyLine((header.version.selectedItem as MajorVersion).version + ".0")
+                    } else {
+                        BodyLine(element)
+                    }
+                },
+                details = when (event) {
+                    is SystemLogEvent -> event.mdc.associate { (key, value) -> key to value }
+                    is WrapperLogEvent -> emptyMap()
+                },
+            )
+        }
     }
 
     inner class GroupingScrollBar : JScrollBar() {
@@ -279,14 +359,12 @@ class LogPanel(
         }
     }
 
-    override val icon: Icon? = null
-
-    class Header(private val totalRows: Int) : JPanel(MigLayout("ins 0, fill, hidemode 3")) {
+    private class Header(private val totalRows: Int) : JPanel(MigLayout("ins 0, fill, hidemode 3")) {
         private val events = JLabel("$totalRows (of $totalRows) events")
 
         val search = JXSearchField("Search")
 
-        val version: JComboBox<MajorVersion> = JComboBox(MajorVersion.values()).apply {
+        val version: JComboBox<MajorVersion> = JComboBox(Vector(MajorVersion.entries)).apply {
             selectedItem = MajorVersion.EightOne
             configureCellRenderer { _, value, _, _, _ ->
                 text = "${value?.version}.*"
@@ -294,6 +372,12 @@ class LogPanel(
         }
         private val versionLabel = JLabel("Version")
 
+        val showOnlyMarked = Action(
+            name = "Show Only Marked",
+            selected = false,
+            action = {},
+        )
+
         private fun updateVersionVisibility() {
             val isVisible = UseHyperlinks.currentValue && HyperlinkStrategy.currentValue == LinkHandlingStrategy.OpenInBrowser
             version.isVisible = isVisible
@@ -302,6 +386,7 @@ class LogPanel(
 
         init {
             add(events, "pushx")
+            add(JCheckBox(showOnlyMarked))
 
             add(versionLabel)
             add(version)
@@ -317,6 +402,91 @@ class LogPanel(
         }
     }
 
+    private inner class Sidebar(rawData: List<LogEvent>) : FlatTabbedPane() {
+        private val names = NamePanel(rawData)
+        private val levels = LevelPanel(rawData)
+
+        private val mdc: MDCPanel? = if (columnList == SystemLogColumns) {
+            @Suppress("UNCHECKED_CAST")
+            MDCPanel(rawData as List<SystemLogEvent>)
+        } else {
+            null
+        }
+
+        private val threads: ThreadPanel? = if (columnList == SystemLogColumns) {
+            @Suppress("UNCHECKED_CAST")
+            ThreadPanel(rawData as List<SystemLogEvent>)
+        } else {
+            null
+        }
+
+        private val time = TimePanel(
+            lowerBound = rawData.first().timestamp,
+            upperBound = rawData.last().timestamp,
+        )
+
+        val filterPanels: List<LogFilterPanel> = listOfNotNull(
+            names,
+            levels,
+            time,
+            mdc,
+            threads,
+        )
+
+        init {
+            tabLayoutPolicy = SCROLL_TAB_LAYOUT
+            tabsPopupPolicy = TabsPopupPolicy.asNeeded
+            scrollButtonsPolicy = ScrollButtonsPolicy.never
+            tabWidthMode = TabWidthMode.equal
+            tabType = TabType.underlined
+            tabHeight = 16
+
+            for (i in filterPanels.indices) {
+                val filterPanel = filterPanels[i]
+                addTab(filterPanel.tabName, filterPanel.component)
+
+                filterPanel.addFilterChangeListener {
+                    filterPanel.updateTabState()
+                    updateData()
+
+                    selectedIndex = i
+                }
+            }
+
+            attachPopupMenu { event ->
+                val tabIndex = indexAtLocation(event.x, event.y)
+                if (tabIndex == -1) return@attachPopupMenu null
+
+                JPopupMenu().apply {
+                    add(
+                        Action("Reset") {
+                            filterPanels[tabIndex].reset()
+                        },
+                    )
+                }
+            }
+        }
+
+        private fun LogFilterPanel.updateTabState() {
+            val index = indexOfComponent(component)
+            if (isFilterApplied()) {
+                setBackgroundAt(index, UIManager.getColor("TabbedPane.focusColor"))
+                setTitleAt(index, "$tabName *")
+            } else {
+                setBackgroundAt(index, UIManager.getColor("TabbedPane.background"))
+                setTitleAt(index, tabName)
+            }
+        }
+
+        override fun updateUI() {
+            super.updateUI()
+            @Suppress("UNNECESSARY_SAFE_CALL")
+            filterPanels?.forEach {
+                it.updateTabState()
+            }
+        }
+    }
+
     companion object {
         private val BACKGROUND = CoroutineScope(Dispatchers.Default)
 
@@ -339,102 +509,31 @@ class LogPanel(
             Duration.ofHours(12),
             Duration.ofDays(1),
         )
-
-        private val DEFAULT_WRAPPER_LOG_TIME_FORMAT = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss")
-            .withZone(ZoneId.systemDefault())
-        private val DEFAULT_WRAPPER_MESSAGE_FORMAT =
-            "^[^|]+\\|(?<jvm>[^|]+)\\|(?<timestamp>[^|]+)\\|(?: (?<level>[TDIWE]) \\[(?<logger>[^]]++)] \\[(?<time>[^]]++)]: (?<message>.*)| (?<stack>.*))\$".toRegex()
-
-        fun parseLogs(lines: Sequence<String>): List<WrapperLogEvent> {
-            val events = mutableListOf<WrapperLogEvent>()
-            val currentStack = mutableListOf<String>()
-            var partialEvent: WrapperLogEvent? = null
-            var lastEventTimestamp: Instant? = null
-
-            fun WrapperLogEvent?.flush() {
-                if (this != null) {
-                    // flush our previously built event
-                    events += this.copy(stacktrace = currentStack.toList())
-                    currentStack.clear()
-                    partialEvent = null
-                }
-            }
-
-            for ((index, line) in lines.withIndex()) {
-                if (line.isBlank()) {
-                    continue
-                }
-
-                val match = DEFAULT_WRAPPER_MESSAGE_FORMAT.matchEntire(line)
-                if (match != null) {
-                    val timestamp by match.groups
-                    val time = DEFAULT_WRAPPER_LOG_TIME_FORMAT.parse(timestamp.value.trim(), Instant::from)
-
-                    // we hit an actual logged event
-                    if (match.groups["level"] != null) {
-                        partialEvent.flush()
-
-                        // now build up a new partial (the next line(s) may have stacktrace)
-                        val level by match.groups
-                        val logger by match.groups
-                        val message by match.groups
-                        lastEventTimestamp = time
-                        partialEvent = WrapperLogEvent(
-                            timestamp = time,
-                            message = message.value.trim(),
-                            logger = logger.value.trim(),
-                            level = Level.valueOf(level.value.single()),
-                        )
-                    } else {
-                        val stack by match.groups
-
-                        if (lastEventTimestamp == time) {
-                            // same timestamp - must be attached stacktrace
-                            currentStack += stack.value
-                        } else {
-                            partialEvent.flush()
-                            // different timestamp, but doesn't match our regex - just try to display it in a useful way
-                            events += WrapperLogEvent(
-                                timestamp = time,
-                                message = stack.value,
-                                level = Level.INFO,
-                            )
-                        }
-                    }
-                } else {
-                    throw IllegalArgumentException("Error parsing line $index, unparseable value: $line")
-                }
-            }
-            partialEvent.flush()
-            return events
-        }
     }
 }
 
-// Credit to https://stackoverflow.com/a/66203968
-class DurationUnit(private val duration: Duration) : TemporalUnit {
-    init {
-        require(!(duration.isZero || duration.isNegative)) { "Duration may not be zero or negative" }
-    }
+fun interface LogFilter {
+    /**
+     * Return true if this filter should display this event.
+     */
+    fun filter(event: LogEvent): Boolean
+}
 
-    override fun getDuration(): Duration = duration
-    override fun isDurationEstimated(): Boolean = duration.seconds >= SECONDS_PER_DAY
-    override fun isDateBased(): Boolean = duration.nano == 0 && duration.seconds % SECONDS_PER_DAY == 0L
-    override fun isTimeBased(): Boolean = duration.seconds < SECONDS_PER_DAY && NANOS_PER_DAY % duration.toNanos() == 0L
+fun interface FilterChangeListener : EventListener {
+    fun filterChanged()
+}
 
-    @Suppress("UNCHECKED_CAST")
-    override fun <R : Temporal?> addTo(temporal: R, amount: Long): R =
-        duration.multipliedBy(amount).addTo(temporal) as R
+interface LogFilterPanel : LogFilter {
+    val tabName: String
+    fun isFilterApplied(): Boolean
+    val component: JComponent
+    fun addFilterChangeListener(listener: FilterChangeListener)
 
-    override fun between(temporal1Inclusive: Temporal, temporal2Exclusive: Temporal): Long {
-        return Duration.between(temporal1Inclusive, temporal2Exclusive).dividedBy(duration)
-    }
+    fun reset()
 
-    override fun toString(): String = duration.toString()
-
-    companion object {
-        private const val SECONDS_PER_DAY = 86400
-        private const val NANOS_PER_SECOND = 1000000000L
-        private const val NANOS_PER_DAY = NANOS_PER_SECOND * SECONDS_PER_DAY
-    }
+    fun customizePopupMenu(
+        menu: JPopupMenu,
+        column: Column<out LogEvent, *>,
+        event: LogEvent,
+    ) = Unit
 }
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/log/LoggerNames.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/log/LoggerNames.kt
deleted file mode 100644
index 5df9cde4..00000000
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/log/LoggerNames.kt
+++ /dev/null
@@ -1,156 +0,0 @@
-package io.github.inductiveautomation.kindling.log
-
-import com.formdev.flatlaf.extras.FlatSVGIcon
-import com.jidesoft.swing.CheckBoxList
-import io.github.inductiveautomation.kindling.core.Kindling.Preferences.General.ShowFullLoggerNames
-import io.github.inductiveautomation.kindling.utils.Action
-import io.github.inductiveautomation.kindling.utils.FlatScrollPane
-import io.github.inductiveautomation.kindling.utils.NoSelectionModel
-import io.github.inductiveautomation.kindling.utils.installSearchable
-import io.github.inductiveautomation.kindling.utils.listCellRenderer
-import net.miginfocom.swing.MigLayout
-import javax.swing.AbstractListModel
-import javax.swing.ButtonGroup
-import javax.swing.JPanel
-import javax.swing.JToggleButton
-import javax.swing.ListModel
-
-data class LoggerName(
-    val name: String,
-    val eventCount: Int,
-)
-
-class LoggerNamesModel(val data: List<LoggerName>) : AbstractListModel<Any>() {
-    override fun getSize(): Int = data.size + 1
-    override fun getElementAt(index: Int): Any {
-        return if (index == 0) {
-            CheckBoxList.ALL_ENTRY
-        } else {
-            data[index - 1]
-        }
-    }
-}
-
-class LoggerNamesList(model: LoggerNamesModel) : CheckBoxList(model) {
-    var isShowFullLoggerName = ShowFullLoggerNames.currentValue
-        set(value) {
-            field = value
-            repaint()
-        }
-
-    private fun displayValue(value: Any?): String {
-        return when (value) {
-            is LoggerName -> if (!isShowFullLoggerName) {
-                value.name.substringAfterLast('.')
-            } else {
-                value.name
-            }
-
-            else -> value.toString()
-        }
-    }
-
-    init {
-        installSearchable(
-            setup = {
-                isCaseSensitive = false
-                isRepeats = true
-                isCountMatch = true
-            },
-            conversion = ::displayValue,
-        )
-        selectionModel = NoSelectionModel()
-        cellRenderer = listCellRenderer<Any> { _, value, _, _, _ ->
-            when (value) {
-                is LoggerName -> {
-                    text = "${displayValue(value)} - [${value.eventCount}]"
-                    toolTipText = value.name
-                }
-
-                else -> {
-                    text = value.toString()
-                }
-            }
-        }
-
-        selectAll()
-    }
-
-    override fun getModel(): LoggerNamesModel = super.getModel() as LoggerNamesModel
-
-    override fun setModel(model: ListModel<*>) {
-        require(model is LoggerNamesModel)
-        val selection = checkBoxListSelectedValues
-        checkBoxListSelectionModel.valueIsAdjusting = true
-        super.setModel(model)
-        addCheckBoxListSelectedValues(selection)
-        checkBoxListSelectionModel.valueIsAdjusting = false
-    }
-}
-
-class LoggerNamesPanel(events: List<LogEvent>) : JPanel(MigLayout("ins 0, fill")) {
-    val list: LoggerNamesList = run {
-        val loggerNames: List<LoggerName> = events.groupingBy { it.logger }
-            .eachCount()
-            .entries
-            .sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.key })
-            .map { (key, value) -> LoggerName(key, value) }
-        LoggerNamesList(LoggerNamesModel(loggerNames))
-    }
-
-    init {
-        val sortButtons = ButtonGroup()
-
-        fun sortButton(icon: FlatSVGIcon, tooltip: String, comparator: Comparator<LoggerName>): JToggleButton {
-            return JToggleButton(
-                Action(
-                    description = tooltip,
-                    icon = icon,
-                ) {
-                    list.model = LoggerNamesModel(list.model.data.sortedWith(comparator))
-                },
-            )
-        }
-
-        val naturalAsc = sortButton(
-            icon = NATURAL_SORT_ASCENDING,
-            tooltip = "Sort A-Z",
-            comparator = byName,
-        )
-        listOf(
-            naturalAsc,
-            sortButton(
-                icon = NATURAL_SORT_DESCENDING,
-                tooltip = "Sort Z-A",
-                comparator = byName.reversed(),
-            ),
-            sortButton(
-                icon = NUMERIC_SORT_DESCENDING,
-                tooltip = "Sort by Count",
-                comparator = byCount.reversed() then byName,
-            ),
-            sortButton(
-                icon = NUMERIC_SORT_ASCENDING,
-                tooltip = "Sort by Count (ascending)",
-                comparator = byCount then byName,
-            ),
-        ).forEach { sortButton ->
-            sortButtons.add(sortButton)
-            add(sortButton, "cell 0 0")
-        }
-
-        sortButtons.setSelected(naturalAsc.model, true)
-
-        add(FlatScrollPane(list), "newline, push, grow")
-    }
-
-    companion object {
-        private val byName = compareBy(String.CASE_INSENSITIVE_ORDER, LoggerName::name)
-        private val byCount = compareBy(LoggerName::eventCount)
-
-        private val NATURAL_SORT_ASCENDING = FlatSVGIcon("icons/bx-sort-a-z.svg")
-        private val NATURAL_SORT_DESCENDING = FlatSVGIcon("icons/bx-sort-z-a.svg")
-        private val NUMERIC_SORT_ASCENDING = FlatSVGIcon("icons/bx-sort-up.svg")
-        private val NUMERIC_SORT_DESCENDING = FlatSVGIcon("icons/bx-sort-down.svg")
-    }
-}
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/log/MDCPanel.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/log/MDCPanel.kt
new file mode 100644
index 00000000..07c3a433
--- /dev/null
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/log/MDCPanel.kt
@@ -0,0 +1,286 @@
+package io.github.inductiveautomation.kindling.log
+
+import com.formdev.flatlaf.extras.FlatSVGIcon
+import io.github.inductiveautomation.kindling.core.Kindling.SECONDARY_ACTION_ICON_SCALE
+import io.github.inductiveautomation.kindling.log.MDCTableModel.MDCColumns
+import io.github.inductiveautomation.kindling.utils.Action
+import io.github.inductiveautomation.kindling.utils.Column
+import io.github.inductiveautomation.kindling.utils.ColumnList
+import io.github.inductiveautomation.kindling.utils.FlatScrollPane
+import io.github.inductiveautomation.kindling.utils.ReifiedJXTable
+import io.github.inductiveautomation.kindling.utils.add
+import io.github.inductiveautomation.kindling.utils.attachPopupMenu
+import io.github.inductiveautomation.kindling.utils.configureCellRenderer
+import io.github.inductiveautomation.kindling.utils.getAll
+import net.miginfocom.swing.MigLayout
+import org.jdesktop.swingx.renderer.CheckBoxProvider
+import org.jdesktop.swingx.renderer.DefaultTableRenderer
+import java.util.Vector
+import javax.swing.DefaultComboBoxModel
+import javax.swing.JButton
+import javax.swing.JComboBox
+import javax.swing.JComponent
+import javax.swing.JMenu
+import javax.swing.JMenuItem
+import javax.swing.JPanel
+import javax.swing.JPopupMenu
+import javax.swing.table.AbstractTableModel
+
+internal class MDCPanel(events: List<SystemLogEvent>) : JPanel(MigLayout("ins 0, fill")), LogFilterPanel {
+    private val allMDCs = events.flatMap(SystemLogEvent::mdc)
+
+    private val countByKey = allMDCs
+        .groupingBy(MDC::key)
+        .eachCount()
+        .entries
+        .sortedByDescending(Map.Entry<String, Int>::value)
+        .associate(Map.Entry<String, Int>::toPair)
+
+    private val countByKeyAndValue = allMDCs
+        .groupingBy(MDC::toPair)
+        .eachCount()
+
+    private val mdcValuesPerKey = allMDCs
+        .groupBy(MDC::key)
+        .mapValues { it.value.distinct() }
+
+    private val tableModel = MDCTableModel()
+
+    private val valueCombo: JComboBox<String?> = JComboBox<String?>().apply {
+        configureCellRenderer { _, value, _, _, _ ->
+            text = if (value == null) {
+                " - value - "
+            } else {
+                val count = countByKeyAndValue[keyCombo.selectedItem as String to value] ?: 0
+                "$value [$count]"
+            }
+            toolTipText = text
+        }
+        selectedIndex = -1
+    }
+
+    private val keyCombo: JComboBox<String> = JComboBox(countByKey.keys.toTypedArray()).apply {
+        configureCellRenderer { _, key, _, _, _ ->
+            text = if (key == null) {
+                " - key - "
+            } else {
+                val count = countByKey[key]
+                "$key [$count]"
+            }
+            toolTipText = text
+        }
+
+        addActionListener {
+            valueCombo.model = mdcValuesPerKey.getValue(selectedItem as String).map { it.value }.let { DefaultComboBoxModel(Vector(it)) }
+        }
+
+        selectedIndex = 0
+    }
+
+    private val addFilter = Action(
+        icon = FlatSVGIcon("icons/bx-plus.svg").derive(SECONDARY_ACTION_ICON_SCALE),
+    ) {
+        val selectedKey = keyCombo.selectedItem as String?
+        val selectedValue = valueCombo.selectedItem as String?
+
+        if (selectedKey != null && selectedValue != null) {
+            filterTable.model.add(selectedKey, selectedValue)
+        }
+    }
+
+    private val removeFilter = Action(
+        name = "Remove Filter",
+        icon = FlatSVGIcon("icons/bx-minus.svg").derive(SECONDARY_ACTION_ICON_SCALE),
+    ) {
+        val rowToRemove = filterTable.selectedRow.takeIf { it != -1 } ?: tableModel.data.lastIndex
+        if (rowToRemove in tableModel.data.indices) {
+            tableModel.removeAt(filterTable.selectedRow)
+
+            val newSelection = rowToRemove.coerceAtMost(tableModel.data.lastIndex)
+            if (newSelection >= 0) {
+                filterTable.setRowSelectionInterval(newSelection, newSelection)
+            }
+        }
+    }
+
+    private val removeAllFilters = Action(
+        name = "Remove All Filters",
+        icon = FlatSVGIcon("icons/bx-x.svg").derive(SECONDARY_ACTION_ICON_SCALE),
+    ) {
+        reset()
+    }
+
+    private val filterTable = ReifiedJXTable(tableModel, MDCColumns).apply {
+        isColumnControlVisible = false
+        tableHeader.apply {
+            reorderingAllowed = false
+        }
+
+        tableModel.addTableModelListener {
+            listenerList.getAll<FilterChangeListener>().forEach(FilterChangeListener::filterChanged)
+        }
+    }
+
+    init {
+        add(keyCombo, "growx, wrap, wmax 100%")
+        add(valueCombo, "growx, wrap, wmax 100%")
+        add(
+            JButton(removeFilter).apply {
+                hideActionText = true
+            },
+            "align right, split",
+        )
+        add(JButton(addFilter), "gapx 2")
+        add(
+            JButton(removeAllFilters).apply {
+                hideActionText = true
+            },
+            "gapx 2",
+        )
+        add(FlatScrollPane(filterTable), "newline, pushy, grow")
+
+        filterTable.attachPopupMenu { mouseEvent ->
+            val rowAtPoint = rowAtPoint(mouseEvent.point)
+            if (rowAtPoint != -1) {
+                filterTable.addRowSelectionInterval(rowAtPoint, rowAtPoint)
+            }
+            JPopupMenu().apply {
+                add(JMenuItem(removeFilter))
+                add(JMenuItem(removeAllFilters))
+            }
+        }
+    }
+
+    override fun isFilterApplied(): Boolean = tableModel.data.isNotEmpty()
+
+    override val component: JComponent = this
+
+    override val tabName: String = "MDC"
+
+    override fun filter(event: LogEvent): Boolean = tableModel.filter(event)
+
+    override fun addFilterChangeListener(listener: FilterChangeListener) {
+        listenerList.add(listener)
+    }
+
+    override fun customizePopupMenu(menu: JPopupMenu, column: Column<out LogEvent, *>, event: LogEvent) {
+        if (column == SystemLogColumns.Message && (event as SystemLogEvent).mdc.isNotEmpty()) {
+            for ((key, values) in event.mdc.groupBy { it.key }) {
+                menu.add(
+                    JMenu("MDC: '$key'").apply {
+                        for (mdc in values) {
+                            add(
+                                Action("Include '${mdc.value}'") {
+                                    tableModel.add(key, mdc.value, true)
+                                },
+                            )
+                            add(
+                                Action("Exclude '${mdc.value}'") {
+                                    tableModel.add(key, mdc.value, false)
+                                },
+                            )
+                        }
+                    },
+                )
+            }
+        }
+    }
+
+    override fun reset() {
+        tableModel.clear()
+    }
+}
+
+data class MDCTableRow(
+    val key: String,
+    val value: String?,
+    var inclusive: Boolean = true,
+) : LogFilter {
+    override fun filter(event: LogEvent): Boolean {
+        check(event is SystemLogEvent)
+        val any = event.mdc.any { (key, value) ->
+            this.key == key && this.value?.equals(value) == true
+        }
+        return if (inclusive) any else !any
+    }
+}
+
+class MDCTableModel : AbstractTableModel(), LogFilter {
+    private val _data: MutableList<MDCTableRow> = mutableListOf()
+    val data: List<MDCTableRow> = _data
+
+    override fun getRowCount(): Int = _data.size
+
+    @Suppress("RedundantCompanionReference")
+    override fun getColumnCount(): Int = MDCColumns.size
+    override fun getValueAt(rowIndex: Int, columnIndex: Int): Any? = get(rowIndex, MDCColumns[columnIndex])
+    override fun getColumnName(column: Int): String = get(column).header
+    override fun getColumnClass(columnIndex: Int): Class<*> = get(columnIndex).clazz
+    override fun isCellEditable(rowIndex: Int, columnIndex: Int): Boolean {
+        return columnIndex == MDCColumns[Inclusive]
+    }
+
+    override fun setValueAt(aValue: Any?, rowIndex: Int, columnIndex: Int) {
+        if (aValue !is Boolean) return
+
+        if (MDCColumns[columnIndex] == Inclusive) {
+            _data[rowIndex].inclusive = aValue
+        }
+
+        fireTableCellUpdated(rowIndex, columnIndex)
+    }
+
+    operator fun <T> get(row: Int, column: Column<MDCTableRow, T>): T {
+        return _data[row].let { info ->
+            column.getValue(info)
+        }
+    }
+
+    override fun filter(event: LogEvent): Boolean {
+        return when (event) {
+            is WrapperLogEvent -> true
+            is SystemLogEvent -> _data.isEmpty() || _data.any { row ->
+                row.filter(event)
+            }
+        }
+    }
+
+    fun removeAt(index: Int) {
+        _data.removeAt(index)
+        fireTableRowsDeleted(index, index)
+    }
+
+    fun add(key: String, value: String?, inclusive: Boolean = true) {
+        val exists = data.any { (existingKey, existingValue) ->
+            key == existingKey && value == existingValue
+        }
+        if (!exists) {
+            _data += MDCTableRow(key, value, inclusive)
+            fireTableRowsInserted(_data.lastIndex, _data.lastIndex)
+        }
+    }
+
+    fun clear() {
+        _data.clear()
+        fireTableDataChanged()
+    }
+
+    companion object MDCColumns : ColumnList<MDCTableRow>() {
+        val Key by column(
+            value = MDCTableRow::key,
+        )
+        val Value by column(
+            value = MDCTableRow::value,
+        )
+        val Inclusive by column(
+            column = {
+                cellRenderer = DefaultTableRenderer(
+                    CheckBoxProvider {
+                        if (it as Boolean) "Inclusive" else "Exclusive"
+                    },
+                )
+            },
+            value = MDCTableRow::inclusive,
+        )
+    }
+}
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/log/SystemLogsEvent.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/log/Model.kt
similarity index 60%
rename from src/main/kotlin/io/github/inductiveautomation/kindling/log/SystemLogsEvent.kt
rename to src/main/kotlin/io/github/inductiveautomation/kindling/log/Model.kt
index eed5431a..69326d62 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/log/SystemLogsEvent.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/log/Model.kt
@@ -4,31 +4,43 @@ import io.github.inductiveautomation.kindling.utils.StackTrace
 import java.time.Instant
 
 sealed interface LogEvent {
+    var marked: Boolean
     val timestamp: Instant
     val message: String
     val logger: String
+    val level: Level?
+    val stacktrace: List<String>
+}
+
+data class MDC(
+    val key: String,
+    val value: String?,
+) {
+    fun toPair() = Pair(key, value)
 }
 
 data class WrapperLogEvent(
     override val timestamp: Instant,
     override val message: String,
     override val logger: String = STDOUT,
-    val level: Level? = null,
-    val stacktrace: StackTrace = emptyList(),
+    override val level: Level? = null,
+    override val stacktrace: StackTrace = emptyList(),
+    override var marked: Boolean = false,
 ) : LogEvent {
     companion object {
         const val STDOUT = "STDOUT"
     }
 }
 
-data class SystemLogsEvent(
+data class SystemLogEvent(
     override val timestamp: Instant,
     override val message: String,
     override val logger: String,
     val thread: String,
-    val level: Level,
-    val mdc: Map<String, String>,
-    val stacktrace: StackTrace,
+    override val level: Level,
+    val mdc: List<MDC>,
+    override val stacktrace: List<String>,
+    override var marked: Boolean = false,
 ) : LogEvent
 
 @Suppress("ktlint:trailing-comma-on-declaration-site")
@@ -40,7 +52,7 @@ enum class Level {
     ERROR;
 
     companion object {
-        private val firstChars = values().associateBy { it.name.first() }
+        private val firstChars = entries.associateBy { it.name.first() }
 
         fun valueOf(char: Char): Level = firstChars.getValue(char)
     }
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/log/NamePanel.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/log/NamePanel.kt
new file mode 100644
index 00000000..2df19f74
--- /dev/null
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/log/NamePanel.kt
@@ -0,0 +1,94 @@
+package io.github.inductiveautomation.kindling.log
+
+import io.github.inductiveautomation.kindling.core.Kindling.Preferences.General.ShowFullLoggerNames
+import io.github.inductiveautomation.kindling.utils.Action
+import io.github.inductiveautomation.kindling.utils.Column
+import io.github.inductiveautomation.kindling.utils.FilterList
+import io.github.inductiveautomation.kindling.utils.FilterModel
+import io.github.inductiveautomation.kindling.utils.FlatScrollPane
+import io.github.inductiveautomation.kindling.utils.add
+import io.github.inductiveautomation.kindling.utils.getAll
+import net.miginfocom.swing.MigLayout
+import javax.swing.ButtonGroup
+import javax.swing.JComponent
+import javax.swing.JPanel
+import javax.swing.JPopupMenu
+import javax.swing.JToggleButton
+
+internal class NamePanel(events: List<LogEvent>) : JPanel(MigLayout("ins 0, fill")), LogFilterPanel {
+    private val countByLogger = events.groupingBy(LogEvent::logger).eachCount()
+
+    private fun getSortKey(key: Any?): String {
+        require(key is String)
+        return if (ShowFullLoggerNames.currentValue) {
+            key
+        } else {
+            key.substringAfterLast('.')
+        }
+    }
+
+    private val filterList = FilterList(
+        toStringFn = ::getSortKey,
+        tooltipToStringFn = Any?::toString,
+    ).apply {
+        setModel(FilterModel(countByLogger, ::getSortKey))
+    }
+
+    init {
+        ShowFullLoggerNames.addChangeListener {
+            filterList.model = filterList.model.copy(filterList.comparator)
+        }
+
+        val bg = ButtonGroup()
+        for (sortAction in filterList.sortActions) {
+            val sortToggle = JToggleButton(sortAction)
+            bg.add(sortToggle)
+            add(sortToggle, "split, gapx 2")
+        }
+
+        add(FlatScrollPane(filterList), "newline, push, grow")
+
+        filterList.selectAll()
+        filterList.checkBoxListSelectionModel.addListSelectionListener { event ->
+            if (!event.valueIsAdjusting) {
+                listenerList.getAll<FilterChangeListener>().forEach(FilterChangeListener::filterChanged)
+            }
+        }
+    }
+
+    override val component: JComponent = this
+    override val tabName: String = "Logger"
+
+    override fun isFilterApplied(): Boolean = filterList.checkBoxListSelectedIndices.size < filterList.model.size - 1
+
+    override fun addFilterChangeListener(listener: FilterChangeListener) {
+        listenerList.add(listener)
+    }
+
+    override fun filter(event: LogEvent): Boolean {
+        return event.logger in filterList.checkBoxListSelectedValues
+    }
+
+    override fun customizePopupMenu(
+        menu: JPopupMenu,
+        column: Column<out LogEvent, *>,
+        event: LogEvent,
+    ) {
+        if (column == WrapperLogColumns.Logger || column == SystemLogColumns.Logger) {
+            val loggerIndex = filterList.model.indexOf(event.logger)
+            menu.add(
+                Action("Show only ${event.logger} events") {
+                    filterList.checkBoxListSelectedIndex = loggerIndex
+                    filterList.ensureIndexIsVisible(loggerIndex)
+                },
+            )
+            menu.add(
+                Action("Exclude ${event.logger} events") {
+                    filterList.removeCheckBoxListSelectedIndex(loggerIndex)
+                },
+            )
+        }
+    }
+
+    override fun reset() = filterList.selectAll()
+}
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/log/TableModel.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/log/TableModel.kt
new file mode 100644
index 00000000..69ab71cb
--- /dev/null
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/log/TableModel.kt
@@ -0,0 +1,173 @@
+package io.github.inductiveautomation.kindling.log
+
+import com.formdev.flatlaf.extras.FlatSVGIcon
+import com.jidesoft.comparator.AlphanumComparator
+import io.github.inductiveautomation.kindling.core.Kindling.Preferences.General.ShowFullLoggerNames
+import io.github.inductiveautomation.kindling.log.LogViewer.TimeStampFormatter
+import io.github.inductiveautomation.kindling.utils.Column
+import io.github.inductiveautomation.kindling.utils.ColumnList
+import io.github.inductiveautomation.kindling.utils.ReifiedLabelProvider
+import org.jdesktop.swingx.renderer.DefaultTableRenderer
+import org.jdesktop.swingx.renderer.StringValues
+import java.time.Instant
+import javax.swing.table.AbstractTableModel
+
+class LogsModel<T : LogEvent>(
+    val data: List<T>,
+    val columns: LogColumnList<T>,
+) : AbstractTableModel() {
+    override fun getColumnName(column: Int): String = columns[column].header
+    override fun getRowCount(): Int = data.size
+    override fun getColumnCount(): Int = columns.size
+    override fun getValueAt(row: Int, column: Int): Any? = get(row, columns[column])
+    override fun getColumnClass(column: Int): Class<*> = columns[column].clazz
+    override fun isCellEditable(rowIndex: Int, columnIndex: Int): Boolean {
+        return columnIndex == markIndex
+    }
+
+    val markIndex = columns[
+        when (columns) {
+            is SystemLogColumns -> SystemLogColumns.Marked
+            is WrapperLogColumns -> WrapperLogColumns.Marked
+        },
+    ]
+
+    operator fun get(row: Int): T = data[row]
+    operator fun <R> get(row: Int, column: Column<T, R>): R? {
+        return data.getOrNull(row)?.let { event ->
+            column.getValue(event)
+        }
+    }
+
+    override fun setValueAt(aValue: Any?, rowIndex: Int, columnIndex: Int) {
+        require(isCellEditable(rowIndex, columnIndex))
+        data[rowIndex].marked = aValue as Boolean
+    }
+
+    /**
+     * Update marks in the model, efficiently.
+     * Return true to set marked, false to clear a mark, or null to bypass the row.
+     */
+    fun markRows(predicate: (T) -> Boolean?) {
+        var firstIndex = -1
+        var lastIndex = -1
+        for ((rowIndex, event) in data.withIndex()) {
+            val shouldMark = predicate(event) ?: continue
+            if (firstIndex == -1) {
+                firstIndex = rowIndex
+            }
+            lastIndex = rowIndex
+            event.marked = shouldMark
+        }
+        fireTableRowsUpdated(firstIndex, lastIndex)
+    }
+}
+
+@Suppress("PropertyName")
+sealed class LogColumnList<T : LogEvent> : ColumnList<T>() {
+    val Marked = Column<T, Boolean>(
+        header = "Marked",
+        columnCustomization = {
+            minWidth = 25
+            maxWidth = 25
+            toolTipText = "Marked Logs"
+            headerRenderer = DefaultTableRenderer(StringValues.EMPTY) {
+                FlatSVGIcon("icons/bx-search.svg").derive(0.8F)
+            }
+        },
+        getValue = LogEvent::marked,
+    )
+
+    val Level = Column<T, Level?>(
+        header = "Level",
+        columnCustomization = {
+            minWidth = 55
+            maxWidth = 55
+        },
+        getValue = LogEvent::level,
+    )
+
+    val Timestamp = Column<T, Instant>(
+        header = "Timestamp",
+        columnCustomization = {
+            minWidth = 155
+            maxWidth = 155
+            cellRenderer = DefaultTableRenderer {
+                (it as? Instant)?.let(TimeStampFormatter::format)
+            }
+        },
+        getValue = LogEvent::timestamp,
+    )
+
+    val Logger = Column<T, String>(
+        header = "Logger",
+        columnCustomization = {
+            minWidth = 50
+
+            val valueExtractor: (String?) -> String? = {
+                if (ShowFullLoggerNames.currentValue) {
+                    it
+                } else {
+                    it?.substringAfterLast('.')
+                }
+            }
+
+            cellRenderer = DefaultTableRenderer(
+                ReifiedLabelProvider(
+                    getText = valueExtractor,
+                    getTooltip = { it },
+                ),
+            )
+            comparator = compareBy(AlphanumComparator(), valueExtractor)
+        },
+        getValue = LogEvent::logger,
+    )
+
+    val Message = Column<T, String>(
+        header = "Message",
+        columnCustomization = {
+            isSortable = false
+        },
+        getValue = LogEvent::message,
+    )
+
+    init {
+        add(Marked)
+        add(Level)
+        add(Logger)
+        add(Message)
+        add(Timestamp)
+    }
+
+    abstract val filterableColumns: List<Column<T, out Any?>>
+}
+
+data object SystemLogColumns : LogColumnList<SystemLogEvent>() {
+    val Thread = Column(
+        header = "Thread",
+        columnCustomization = {
+            minWidth = 50
+            isSortable = false
+        },
+        getValue = SystemLogEvent::thread,
+    )
+
+    init {
+        add(Thread)
+    }
+
+    override val filterableColumns = listOf(
+        Level,
+        Thread,
+        Logger,
+        Message,
+    )
+}
+
+data object WrapperLogColumns : LogColumnList<WrapperLogEvent>() {
+    override val filterableColumns = listOf(
+        Level,
+        Logger,
+        Message,
+    )
+}
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/log/ThreadPanel.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/log/ThreadPanel.kt
new file mode 100644
index 00000000..8272e9ae
--- /dev/null
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/log/ThreadPanel.kt
@@ -0,0 +1,75 @@
+package io.github.inductiveautomation.kindling.log
+
+import io.github.inductiveautomation.kindling.utils.Action
+import io.github.inductiveautomation.kindling.utils.Column
+import io.github.inductiveautomation.kindling.utils.FilterList
+import io.github.inductiveautomation.kindling.utils.FilterModel
+import io.github.inductiveautomation.kindling.utils.FlatScrollPane
+import io.github.inductiveautomation.kindling.utils.add
+import io.github.inductiveautomation.kindling.utils.getAll
+import net.miginfocom.swing.MigLayout
+import javax.swing.ButtonGroup
+import javax.swing.JComponent
+import javax.swing.JPanel
+import javax.swing.JPopupMenu
+import javax.swing.JToggleButton
+
+internal class ThreadPanel(events: List<LogEvent>) : JPanel(MigLayout("ins 0, fill")), LogFilterPanel {
+    private val filterList = FilterList().apply {
+        setModel(FilterModel(events.groupingBy { (it as SystemLogEvent).thread }.eachCount()))
+    }
+
+    init {
+        val bg = ButtonGroup()
+        for (sortAction in filterList.sortActions) {
+            val sortToggle = JToggleButton(sortAction)
+            bg.add(sortToggle)
+            add(sortToggle, "split, gapx 2")
+        }
+
+        add(FlatScrollPane(filterList), "newline, push, grow")
+
+        filterList.selectAll()
+        filterList.checkBoxListSelectionModel.addListSelectionListener { event ->
+            if (!event.valueIsAdjusting) {
+                listenerList.getAll<FilterChangeListener>().forEach(FilterChangeListener::filterChanged)
+            }
+        }
+    }
+
+    override val component: JComponent = this
+    override val tabName: String = "Thread"
+
+    override fun isFilterApplied(): Boolean = filterList.checkBoxListSelectedIndices.size < filterList.model.size - 1
+
+    override fun addFilterChangeListener(listener: FilterChangeListener) {
+        listenerList.add(listener)
+    }
+
+    override fun filter(event: LogEvent): Boolean {
+        return (event as SystemLogEvent).thread in filterList.checkBoxListSelectedValues
+    }
+
+    override fun customizePopupMenu(
+        menu: JPopupMenu,
+        column: Column<out LogEvent, *>,
+        event: LogEvent,
+    ) {
+        if (column == SystemLogColumns.Thread) {
+            val threadIndex = filterList.model.indexOf((event as SystemLogEvent).thread)
+            menu.add(
+                Action("Show only ${event.thread} events") {
+                    filterList.checkBoxListSelectedIndex = threadIndex
+                    filterList.ensureIndexIsVisible(threadIndex)
+                },
+            )
+            menu.add(
+                Action("Exclude ${event.thread} events") {
+                    filterList.removeCheckBoxListSelectedIndex(threadIndex)
+                },
+            )
+        }
+    }
+
+    override fun reset() = filterList.selectAll()
+}
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/log/TimePanel.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/log/TimePanel.kt
new file mode 100644
index 00000000..489e1328
--- /dev/null
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/log/TimePanel.kt
@@ -0,0 +1,290 @@
+package io.github.inductiveautomation.kindling.log
+
+import io.github.inductiveautomation.kindling.core.Kindling.Preferences.UI.Theme
+import io.github.inductiveautomation.kindling.log.LogViewer.TimeStampFormatter
+import io.github.inductiveautomation.kindling.utils.Action
+import io.github.inductiveautomation.kindling.utils.Column
+import io.github.inductiveautomation.kindling.utils.EmptyBorder
+import io.github.inductiveautomation.kindling.utils.add
+import io.github.inductiveautomation.kindling.utils.getAll
+import net.miginfocom.swing.MigLayout
+import org.jdesktop.swingx.JXDatePicker
+import java.awt.Cursor
+import java.awt.event.MouseAdapter
+import java.awt.event.MouseEvent
+import java.time.Instant
+import java.time.LocalDate
+import java.time.LocalTime
+import java.time.ZonedDateTime
+import java.time.temporal.ChronoField
+import java.time.temporal.ChronoField.HOUR_OF_DAY
+import java.time.temporal.ChronoField.MILLI_OF_SECOND
+import java.time.temporal.ChronoField.MINUTE_OF_HOUR
+import java.time.temporal.ChronoField.SECOND_OF_MINUTE
+import java.time.temporal.WeekFields
+import java.util.Date
+import java.util.Locale
+import javax.swing.JButton
+import javax.swing.JComponent
+import javax.swing.JLabel
+import javax.swing.JPanel
+import javax.swing.JPopupMenu
+import javax.swing.JSpinner
+import javax.swing.SpinnerModel
+import javax.swing.SpinnerNumberModel
+import javax.swing.SwingConstants
+import javax.swing.UIManager
+import javax.swing.border.LineBorder
+
+internal class TimePanel(
+    private val lowerBound: Instant,
+    private val upperBound: Instant,
+) : JPanel(MigLayout("ins 0, fill, wrap 1")), LogFilterPanel {
+    private var coveredRange: ClosedRange<Instant> = lowerBound..upperBound
+    private val initialRange = coveredRange
+
+    private val startSelector = DateTimeSelector(lowerBound, initialRange)
+    private val endSelector = DateTimeSelector(upperBound, initialRange)
+
+    private val resetRange = Action("Reset") {
+        reset()
+    }
+
+    init {
+        add(startSelector, "pushx, growx")
+        add(
+            JLabel("To").apply {
+                horizontalAlignment = SwingConstants.CENTER
+            },
+            "align center, growx",
+        )
+        add(endSelector, "pushx, growx")
+        add(JButton(resetRange), "top, right, pushy")
+
+        startSelector.addPropertyChangeListener("time") {
+            updateCoveredRange()
+        }
+        endSelector.addPropertyChangeListener("time") {
+            updateCoveredRange()
+        }
+    }
+
+    private fun updateCoveredRange() {
+        coveredRange = startSelector.time..endSelector.time
+
+        listenerList.getAll<FilterChangeListener>().forEach(FilterChangeListener::filterChanged)
+    }
+
+    override fun isFilterApplied(): Boolean = coveredRange != initialRange
+
+    override val tabName: String = "Time"
+
+    override val component: JComponent = this
+
+    override fun filter(event: LogEvent): Boolean = event.timestamp in coveredRange
+
+    override fun addFilterChangeListener(listener: FilterChangeListener) {
+        listenerList.add(listener)
+    }
+
+    override fun customizePopupMenu(
+        menu: JPopupMenu,
+        column: Column<out LogEvent, *>,
+        event: LogEvent,
+    ) {
+        if (column == WrapperLogColumns.Timestamp || column == SystemLogColumns.Timestamp) {
+            menu.add(
+                Action("Show only events after ${TimeStampFormatter.format(event.timestamp)}") {
+                    startSelector.time = event.timestamp
+                },
+            )
+            menu.add(
+                Action("Show only events before ${TimeStampFormatter.format(event.timestamp)}") {
+                    endSelector.time = event.timestamp
+                },
+            )
+        }
+    }
+
+    override fun reset() {
+        startSelector.time = lowerBound
+        endSelector.time = upperBound
+        updateCoveredRange()
+    }
+}
+
+private var JXDatePicker.localDate: LocalDate?
+    get() = date?.toInstant()?.let { LocalDate.ofInstant(it, LogViewer.SelectedTimeZone.currentValue) }
+    set(value) {
+        date = value?.atStartOfDay()
+            ?.atOffset(LogViewer.SelectedTimeZone.currentValue.rules.getOffset(value.atStartOfDay()))
+            ?.toInstant()
+            .let(Date::from)
+    }
+
+class DateTimeSelector(
+    private val initialValue: Instant,
+    private val range: ClosedRange<Instant>,
+) : JPanel(MigLayout("ins 0, fillx")) {
+    private val initialZonedTime = initialValue.atZone(LogViewer.SelectedTimeZone.currentValue)
+
+    private var datePicker = JXDatePicker().apply {
+        localDate = initialZonedTime.toLocalDate()
+        editor.horizontalAlignment = SwingConstants.CENTER
+        monthView.apply {
+            // adjust calendar from java.time to java.util weekday numbering
+            firstDayOfWeek = WeekFields.of(Locale.getDefault()).firstDayOfWeek.value % 7 + 1
+
+            lowerBound = Date.from(range.start)
+            upperBound = Date.from(range.endInclusive)
+        }
+        linkPanel = JPanel() // can't be null or BasicDatePickerUI throws an NPE on theme change
+
+        addActionListener {
+            if (date == null) { // out of range selection sets null in JXDatePicker - we'll be nicer and reset
+                localDate = initialZonedTime.toLocalDate()
+            } else {
+                firePropertyChange("time", null, time)
+            }
+        }
+    }
+
+    private val timeSelector = TimeSelector().apply {
+        localTime = initialZonedTime.toLocalTime()
+        addPropertyChangeListener("localTime") {
+            firePropertyChange("time", null, time)
+        }
+    }
+
+    var time: Instant
+        get() {
+            val localDate = datePicker.localDate
+            return if (localDate == null) {
+                initialValue
+            } else {
+                ZonedDateTime.of(
+                    localDate,
+                    timeSelector.localTime,
+                    LogViewer.SelectedTimeZone.currentValue,
+                ).toInstant() ?: initialValue
+            }
+        }
+        set(value) {
+            val zonedDateTime = value.atZone(LogViewer.SelectedTimeZone.currentValue)
+            datePicker.localDate = zonedDateTime.toLocalDate()
+            timeSelector.localTime = zonedDateTime.toLocalTime()
+        }
+
+    init {
+        add(datePicker, "growx, pushx, wrap")
+        add(timeSelector, "growx, pushx")
+    }
+}
+
+class TimeSelector : JPanel(MigLayout("fill, ins 0")) {
+    private val hourSelector = timePartSpinner(HOUR_OF_DAY, "00", 10)
+    private val minuteSelector = timePartSpinner(MINUTE_OF_HOUR, ":00", 6)
+    private val secondSelector = timePartSpinner(SECOND_OF_MINUTE, ":00", 6)
+    private val milliSelector = timePartSpinner(MILLI_OF_SECOND, "'.'000", 1)
+
+    private fun timePartSpinner(
+        field: ChronoField,
+        pattern: String,
+        pixelsPerValueChange: Int,
+    ) = TimePartSpinner(ChronoSpinnerModel(field, pattern), pixelsPerValueChange).apply {
+        addChangeListener {
+            firePropertyChange("localTime", null, localTime)
+        }
+    }
+
+    init {
+        background = UIManager.getColor("ComboBox.background")
+        border = LineBorder(UIManager.getColor("Button.borderColor"))
+        add(hourSelector, "wmin 45, growx")
+        add(minuteSelector, "wmin 45, growx")
+        add(secondSelector, "wmin 45, growx")
+        add(milliSelector, "wmin 55, growx")
+
+        Theme.addChangeListener {
+            background = UIManager.getColor("ComboBox.background")
+            border = LineBorder(UIManager.getColor("Button.borderColor"))
+        }
+    }
+
+    var localTime: LocalTime
+        get() = LocalTime.of(
+            hourSelector.value.toInt(),
+            minuteSelector.value.toInt(),
+            secondSelector.value.toInt(),
+            (milliSelector.value * 1_000_000).toInt(), // milli-of-second to nano-of-second
+        )
+        set(value) {
+            hourSelector.value = value.hour.toLong()
+            minuteSelector.value = value.minute.toLong()
+            secondSelector.value = value.second.toLong()
+            milliSelector.value = (value.nano / 1_000_000).toLong() // milli-of-second to nano-of-second
+        }
+}
+
+private class TimePartSpinner(
+    model: ChronoSpinnerModel,
+    pixelsPerValueChange: Int,
+) : JSpinner(model) {
+    var isSelection = true
+
+    private val dragListener = object : MouseAdapter() {
+        private var previousY = 0
+
+        override fun mouseDragged(e: MouseEvent) {
+            if (e.y < 0 || e.y > height) {
+                val deltaY = previousY - (e.y / pixelsPerValueChange)
+                var currentValue = value + deltaY
+                if (deltaY < 0 && previousY == 0) {
+                    currentValue += height
+                }
+                value = currentValue.coerceIn(0, model.maximum)
+            }
+            previousY = e.y / pixelsPerValueChange
+        }
+
+        override fun mouseReleased(e: MouseEvent) {
+            isSelection = true
+            previousY = 0
+            fireStateChanged()
+        }
+
+        override fun mousePressed(e: MouseEvent) {
+            isSelection = false
+        }
+    }
+
+    override fun createEditor(model: SpinnerModel): JComponent {
+        check(model is ChronoSpinnerModel)
+        return NumberEditor(this, model.pattern).apply {
+            textField.apply {
+                border = EmptyBorder()
+                cursor = Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR)
+            }
+        }
+    }
+
+    init {
+        border = EmptyBorder()
+        isOpaque = false
+        (editor as DefaultEditor).textField.apply {
+            addMouseMotionListener(dragListener)
+            addMouseListener(dragListener)
+        }
+    }
+
+    override fun getValue(): Long = super.getValue() as Long
+
+    override fun getModel(): ChronoSpinnerModel = super.getModel() as ChronoSpinnerModel
+}
+
+private class ChronoSpinnerModel(
+    field: ChronoField,
+    val pattern: String,
+) : SpinnerNumberModel(0L, field.range().minimum, field.range().maximum, 1L) {
+    override fun getMaximum(): Long = super.getMaximum() as Long
+}
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/log/WrapperLogView.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/log/WrapperLogView.kt
index e891fdde..9bdfbd94 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/log/WrapperLogView.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/log/WrapperLogView.kt
@@ -1,7 +1,9 @@
 package io.github.inductiveautomation.kindling.log
 
 import com.formdev.flatlaf.extras.FlatSVGIcon
+import com.jidesoft.comparator.AlphanumComparator
 import io.github.inductiveautomation.kindling.core.ClipboardTool
+import io.github.inductiveautomation.kindling.core.Kindling.Preferences.General.DefaultEncoding
 import io.github.inductiveautomation.kindling.core.MultiTool
 import io.github.inductiveautomation.kindling.core.Preference
 import io.github.inductiveautomation.kindling.core.Preference.Companion.PreferenceCheckbox
@@ -10,9 +12,11 @@ import io.github.inductiveautomation.kindling.core.PreferenceCategory
 import io.github.inductiveautomation.kindling.core.ToolPanel
 import io.github.inductiveautomation.kindling.utils.Action
 import io.github.inductiveautomation.kindling.utils.ZoneIdSerializer
+import io.github.inductiveautomation.kindling.utils.getValue
 import java.awt.Desktop
 import java.io.File
 import java.nio.file.Path
+import java.time.Instant
 import java.time.LocalTime
 import java.time.ZoneId
 import java.time.format.DateTimeFormatter
@@ -53,21 +57,101 @@ class WrapperLogView(
             )
         }
     }
+
+    companion object {
+        private val DEFAULT_WRAPPER_LOG_TIME_FORMAT = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss")
+            .withZone(ZoneId.systemDefault())
+        private val DEFAULT_WRAPPER_MESSAGE_FORMAT =
+            "^[^|]+\\|(?<jvm>[^|]+)\\|(?<timestamp>[^|]+)\\|(?: (?<level>[TDIWE]) \\[(?<logger>[^]]++)] \\[(?<time>[^]]++)]: (?<message>.*)| (?<stack>.*))\$".toRegex()
+
+        fun parseLogs(lines: Sequence<String>): List<WrapperLogEvent> {
+            val events = mutableListOf<WrapperLogEvent>()
+            val currentStack = mutableListOf<String>()
+            var partialEvent: WrapperLogEvent? = null
+            var lastEventTimestamp: Instant? = null
+
+            fun WrapperLogEvent?.flush() {
+                if (this != null) {
+                    // flush our previously built event
+                    events += this.copy(stacktrace = currentStack.toList())
+                    currentStack.clear()
+                    partialEvent = null
+                }
+            }
+
+            for ((index, line) in lines.withIndex()) {
+                if (line.isBlank()) {
+                    continue
+                }
+
+                val match = DEFAULT_WRAPPER_MESSAGE_FORMAT.matchEntire(line)
+                if (match != null) {
+                    val timestamp by match.groups
+                    val time = DEFAULT_WRAPPER_LOG_TIME_FORMAT.parse(timestamp.value.trim(), Instant::from)
+
+                    // we hit an actual logged event
+                    if (match.groups["level"] != null) {
+                        partialEvent.flush()
+
+                        // now build up a new partial (the next line(s) may have stacktrace)
+                        val level by match.groups
+                        val logger by match.groups
+                        val message by match.groups
+                        lastEventTimestamp = time
+                        partialEvent = WrapperLogEvent(
+                            timestamp = time,
+                            message = message.value.trim(),
+                            logger = logger.value.trim(),
+                            level = Level.valueOf(level.value.single()),
+                        )
+                    } else {
+                        val stack by match.groups
+
+                        if (lastEventTimestamp == time) {
+                            // same timestamp - must be attached stacktrace
+                            currentStack += stack.value
+                        } else {
+                            partialEvent.flush()
+                            // different timestamp, but doesn't match our regex - just try to display it in a useful way
+                            events += WrapperLogEvent(
+                                timestamp = time,
+                                message = stack.value,
+                                level = Level.INFO,
+                            )
+                        }
+                    }
+                } else {
+                    throw IllegalArgumentException("Error parsing line $index, unparseable value: $line")
+                }
+            }
+            partialEvent.flush()
+            return events
+        }
+    }
 }
 
-object LogViewer : MultiTool, ClipboardTool, PreferenceCategory {
+data object LogViewer : MultiTool, ClipboardTool, PreferenceCategory {
     override val title = "Wrapper Log"
     override val description = "wrapper.log(.n) files"
     override val icon = FlatSVGIcon("icons/bx-file.svg")
-    override val extensions = listOf("log", "1", "2", "3", "4", "5")
+    override val extensions = List(21) { i ->
+        if (i == 0) {
+            "log"
+        } else {
+            i.toString()
+        }
+    }
+    override val respectsEncoding: Boolean = true
 
     override fun open(paths: List<Path>): ToolPanel {
         require(paths.isNotEmpty()) { "Must provide at least one path" }
-        val events = paths.flatMap { path ->
-            path.useLines { lines -> LogPanel.parseLogs(lines) }
+        // flip the paths, so the .5, .4, .3, .2, .1 - this hopefully helps with the per-event sort below
+        val reverseOrder = paths.sortedWith(compareBy(AlphanumComparator(), Path::name).reversed())
+        val events = reverseOrder.flatMap { path ->
+            path.useLines(DefaultEncoding.currentValue) { lines -> WrapperLogView.parseLogs(lines) }
         }
         return WrapperLogView(
-            events = events,
+            events = events.sortedBy { it.timestamp },
             tabName = paths.first().name,
             fromFile = true,
         )
@@ -75,7 +159,7 @@ object LogViewer : MultiTool, ClipboardTool, PreferenceCategory {
 
     override fun open(data: String): ToolPanel {
         return WrapperLogView(
-            events = LogPanel.parseLogs(data.lineSequence()),
+            events = WrapperLogView.parseLogs(data.lineSequence()),
             tabName = "Paste at ${LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"))}",
             fromFile = false,
         )
@@ -96,6 +180,18 @@ object LogViewer : MultiTool, ClipboardTool, PreferenceCategory {
         },
     )
 
+    private lateinit var _formatter: DateTimeFormatter
+    val TimeStampFormatter: DateTimeFormatter
+        get() {
+            if (!this::_formatter.isInitialized) {
+                _formatter = DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm:ss:SSS").withZone(SelectedTimeZone.currentValue)
+            }
+            if (_formatter.zone != SelectedTimeZone.currentValue) {
+                _formatter = _formatter.withZone(SelectedTimeZone.currentValue)
+            }
+            return _formatter
+        }
+
     val ShowDensity = preference(
         name = "Density Display",
         default = true,
@@ -105,5 +201,6 @@ object LogViewer : MultiTool, ClipboardTool, PreferenceCategory {
     )
 
     override val displayName: String = "Log View"
+    override val key: String = "logview"
     override val preferences: List<Preference<*>> = listOf(SelectedTimeZone, ShowDensity)
 }
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/log/models.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/log/models.kt
deleted file mode 100644
index efc8a9d4..00000000
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/log/models.kt
+++ /dev/null
@@ -1,133 +0,0 @@
-package io.github.inductiveautomation.kindling.log // ktlint-disable filename
-
-import com.jidesoft.comparator.AlphanumComparator
-import io.github.inductiveautomation.kindling.core.Kindling.Preferences.General.ShowFullLoggerNames
-import io.github.inductiveautomation.kindling.utils.Column
-import io.github.inductiveautomation.kindling.utils.ColumnList
-import io.github.inductiveautomation.kindling.utils.ReifiedLabelProvider
-import org.jdesktop.swingx.renderer.DefaultTableRenderer
-import java.time.Instant
-import javax.swing.table.AbstractTableModel
-
-class LogsModel<T : LogEvent>(
-    val data: List<T>,
-    val columns: ColumnList<T>,
-) : AbstractTableModel() {
-    override fun getColumnName(column: Int): String = columns[column].header
-    override fun getRowCount(): Int = data.size
-    override fun getColumnCount(): Int = columns.size
-    override fun getValueAt(row: Int, column: Int): Any? = get(row, columns[column])
-    override fun getColumnClass(column: Int): Class<*> = columns[column].clazz
-
-    operator fun get(row: Int): T = data[row]
-    operator fun <R> get(row: Int, column: Column<T, R>): R? {
-        return data.getOrNull(row)?.let { event ->
-            column.getValue(event)
-        }
-    }
-}
-
-@Suppress("unused", "PropertyName")
-class SystemLogsColumns(panel: LogPanel) : ColumnList<SystemLogsEvent>() {
-    val Level by column(
-        column = {
-            minWidth = 55
-            maxWidth = 55
-        },
-        value = { it.level },
-    )
-    val Timestamp by column(
-        column = {
-            minWidth = 155
-            maxWidth = 155
-            cellRenderer = DefaultTableRenderer {
-                panel.dateFormatter.format(it as Instant)
-            }
-        },
-        value = SystemLogsEvent::timestamp,
-    )
-    val Thread by column(
-        column = {
-            minWidth = 50
-        },
-        value = { it.thread },
-    )
-    val Logger by column(
-        column = {
-            minWidth = 50
-
-            val valueExtractor: (String?) -> String? = {
-                if (ShowFullLoggerNames.currentValue) {
-                    it
-                } else {
-                    it?.substringAfterLast('.')
-                }
-            }
-
-            cellRenderer = DefaultTableRenderer(
-                ReifiedLabelProvider(
-                    getText = valueExtractor,
-                    getTooltip = { it },
-                ),
-            )
-            comparator = compareBy(AlphanumComparator(), valueExtractor)
-        },
-        value = SystemLogsEvent::logger,
-    )
-
-    val Message by column(
-        column = {
-            isSortable = false
-        },
-        value = { it.message },
-    )
-}
-
-@Suppress("unused", "PropertyName")
-class WrapperLogColumns(panel: LogPanel) : ColumnList<WrapperLogEvent>() {
-    val Level by column(
-        column = {
-            minWidth = 55
-            maxWidth = 55
-        },
-        value = { it.level },
-    )
-    val Timestamp by column(
-        column = {
-            minWidth = 155
-            maxWidth = 155
-            cellRenderer = DefaultTableRenderer {
-                panel.dateFormatter.format(it as Instant)
-            }
-        },
-        value = { it.timestamp },
-    )
-    val Logger by column(
-        column = {
-            minWidth = 50
-
-            val valueExtractor: (String?) -> String? = {
-                if (ShowFullLoggerNames.currentValue) {
-                    it
-                } else {
-                    it?.substringAfterLast('.')
-                }
-            }
-
-            cellRenderer = DefaultTableRenderer(
-                ReifiedLabelProvider(
-                    getText = valueExtractor,
-                    getTooltip = { it },
-                ),
-            )
-            comparator = compareBy(AlphanumComparator(), valueExtractor)
-        },
-        value = { it.logger },
-    )
-    val Message by column(
-        column = {
-            isSortable = false
-        },
-        value = { it.message },
-    )
-}
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/thread/FilterList.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/thread/FilterList.kt
deleted file mode 100644
index 123e407f..00000000
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/thread/FilterList.kt
+++ /dev/null
@@ -1,113 +0,0 @@
-package io.github.inductiveautomation.kindling.thread
-
-import com.jidesoft.swing.CheckBoxList
-import com.jidesoft.swing.ListSearchable
-import io.github.inductiveautomation.kindling.utils.NoSelectionModel
-import io.github.inductiveautomation.kindling.utils.listCellRenderer
-import java.text.DecimalFormat
-import javax.swing.AbstractListModel
-import javax.swing.ListModel
-
-typealias FilterComparator = Comparator<Map.Entry<String?, Int>>
-
-class FilterModel(val rawData: Map<String?, Int>) : AbstractListModel<Any>() {
-    var comparator: FilterComparator = byCountDesc
-        set(value) {
-            values = rawData.entries.sortedWith(value).map { it.key }
-            fireContentsChanged(this, 0, size)
-            field = value
-        }
-
-    private var values = rawData.entries.sortedWith(comparator).map { it.key }
-
-    override fun getSize(): Int = values.size + 1
-    override fun getElementAt(index: Int): Any? {
-        return if (index == 0) {
-            CheckBoxList.ALL_ENTRY
-        } else {
-            values[index - 1]
-        }
-    }
-
-    fun indexOf(value: String): Int {
-        val indexOf = values.indexOf(value)
-        return if (indexOf >= 0) {
-            indexOf + 1
-        } else {
-            -1
-        }
-    }
-
-    companion object {
-        val byNameAsc: FilterComparator = compareBy(nullsFirst(String.CASE_INSENSITIVE_ORDER)) { it.key }
-        val byNameDesc: FilterComparator = byNameAsc.reversed()
-        val byCountAsc: FilterComparator = compareBy { it.value }
-        val byCountDesc: FilterComparator = byCountAsc.reversed()
-    }
-}
-
-class FilterList(private val emptyLabel: String) : CheckBoxList(FilterModel(emptyMap())) {
-    private var total = 0
-    private var percentages = emptyMap<String?, String>()
-
-    private var lastSelection = arrayOf<Any>()
-
-    init {
-        selectionModel = NoSelectionModel()
-        isClickInCheckBoxOnly = false
-
-        cellRenderer = listCellRenderer<Any?> { _, value, _, _, _ ->
-            text = when (value) {
-                is String -> "$value - ${model.rawData[value]} (${percentages.getValue(value)})"
-                null -> "$emptyLabel - ${model.rawData[null]} (${percentages.getValue(null)})"
-                else -> value.toString()
-            }
-        }
-
-        object : ListSearchable(this) {
-            init {
-                isCaseSensitive = false
-                isRepeats = true
-                isCountMatch = true
-            }
-
-            override fun convertElementToString(element: Any?): String = element.toString()
-
-            override fun setSelectedIndex(index: Int, incremental: Boolean) {
-                checkBoxListSelectedIndex = index
-            }
-        }
-    }
-
-    fun select(value: String) {
-        val rowToSelect = model.indexOf(value)
-        checkBoxListSelectionModel.setSelectionInterval(rowToSelect, rowToSelect)
-    }
-
-    override fun getModel(): FilterModel = super.getModel() as FilterModel
-
-    override fun setModel(model: ListModel<*>) {
-        require(model is FilterModel)
-        val currentSelection = checkBoxListSelectedValues
-        lastSelection = if (currentSelection.isEmpty()) {
-            lastSelection
-        } else {
-            currentSelection
-        }
-
-        try {
-            checkBoxListSelectionModel.valueIsAdjusting = true
-
-            super.setModel(model)
-
-            total = model.rawData.values.sum()
-            percentages = model.rawData.mapValues { (_, count) ->
-                val percentage = count.toFloat() / total
-                DecimalFormat.getPercentInstance().format(percentage)
-            }
-            addCheckBoxListSelectedValues(lastSelection)
-        } finally {
-            checkBoxListSelectionModel.valueIsAdjusting = false
-        }
-    }
-}
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/thread/MultiThreadView.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/thread/MultiThreadView.kt
index 4ca86fc8..8e414198 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/thread/MultiThreadView.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/thread/MultiThreadView.kt
@@ -14,11 +14,8 @@ import io.github.inductiveautomation.kindling.core.PreferenceCategory
 import io.github.inductiveautomation.kindling.core.ToolOpeningException
 import io.github.inductiveautomation.kindling.core.ToolPanel
 import io.github.inductiveautomation.kindling.core.add
-import io.github.inductiveautomation.kindling.thread.FilterModel.Companion.byCountAsc
-import io.github.inductiveautomation.kindling.thread.FilterModel.Companion.byCountDesc
-import io.github.inductiveautomation.kindling.thread.FilterModel.Companion.byNameAsc
-import io.github.inductiveautomation.kindling.thread.FilterModel.Companion.byNameDesc
 import io.github.inductiveautomation.kindling.thread.model.Thread
+import io.github.inductiveautomation.kindling.thread.model.ThreadColumnIdentifier
 import io.github.inductiveautomation.kindling.thread.model.ThreadDump
 import io.github.inductiveautomation.kindling.thread.model.ThreadLifespan
 import io.github.inductiveautomation.kindling.thread.model.ThreadModel
@@ -27,6 +24,8 @@ import io.github.inductiveautomation.kindling.thread.model.ThreadModel.SingleThr
 import io.github.inductiveautomation.kindling.utils.Action
 import io.github.inductiveautomation.kindling.utils.Column
 import io.github.inductiveautomation.kindling.utils.EDT_SCOPE
+import io.github.inductiveautomation.kindling.utils.FilterList
+import io.github.inductiveautomation.kindling.utils.FilterModel
 import io.github.inductiveautomation.kindling.utils.FlatScrollPane
 import io.github.inductiveautomation.kindling.utils.ReifiedJXTable
 import io.github.inductiveautomation.kindling.utils.attachPopupMenu
@@ -46,7 +45,6 @@ import java.awt.Rectangle
 import java.nio.file.Files
 import java.nio.file.Path
 import javax.swing.ButtonGroup
-import javax.swing.Icon
 import javax.swing.JLabel
 import javax.swing.JMenu
 import javax.swing.JMenuBar
@@ -69,9 +67,9 @@ class MultiThreadView(
         ThreadDump.fromStream(path.inputStream()) ?: throw ToolOpeningException("Failed to open $path as a thread dump")
     }
 
-    private val poolList = FilterList("(No Pool)")
-    private val systemList = FilterList("Unassigned")
-    private val stateList = FilterList("")
+    private val poolList = FilterList { it?.toString() ?: "(No Pool)" }
+    private val systemList = FilterList { it?.toString() ?: "Unassigned" }
+    private val stateList = FilterList()
     private val searchField = JXSearchField("Search")
 
     private var visibleThreadDumps: List<ThreadDump?> = emptyList()
@@ -85,9 +83,9 @@ class MultiThreadView(
             field = value
             val allThreads = value.flatten().filterNotNull()
             if (allThreads.isNotEmpty()) {
-                stateList.model = FilterModel(allThreads.groupingBy { it.state.toString() }.eachCount())
-                systemList.model = FilterModel(allThreads.groupingBy(Thread::system).eachCount())
-                poolList.model = FilterModel(allThreads.groupingBy(Thread::pool).eachCount())
+                stateList.setModel(FilterModel(allThreads.groupingBy { it.state.name }.eachCount()))
+                systemList.setModel(FilterModel(allThreads.groupingBy(Thread::system).eachCount()))
+                poolList.setModel(FilterModel(allThreads.groupingBy(Thread::pool).eachCount()))
             }
             if (initialized) {
                 updateData()
@@ -102,7 +100,8 @@ class MultiThreadView(
         ReifiedJXTable(initialModel).apply {
             columnFactory = initialModel.columns.toColumnFactory()
             createDefaultColumnsFromModel()
-            setSortOrder(initialModel.columns[initialModel.columns.id], SortOrder.ASCENDING)
+            setSortOrder(ThreadColumnIdentifier.ID, SortOrder.ASCENDING)
+
             selectionMode = ListSelectionModel.SINGLE_SELECTION
 
             addHighlighter(
@@ -156,22 +155,25 @@ class MultiThreadView(
                 }
             }
 
-            actionMap.put(
-                "${ColumnControlButton.COLUMN_CONTROL_MARKER}.clearAllMarks",
-                Action(name = "Clear All Marks") {
-                    for (lifespan in model.threadData) {
-                        lifespan.forEach { thread ->
-                            thread?.marked = false
-                        }
+            val clearAllMarks = Action(name = "Clear all marks") {
+                for (lifespan in model.threadData) {
+                    lifespan.forEach { thread ->
+                        thread?.marked = false
                     }
-                },
-            )
+                }
+            }
+            actionMap.put("${ColumnControlButton.COLUMN_CONTROL_MARKER}.clearAllMarks", clearAllMarks)
 
             attachPopupMenu table@{ event ->
                 val rowAtPoint = rowAtPoint(event.point)
                 selectionModel.setSelectionInterval(rowAtPoint, rowAtPoint)
 
                 JPopupMenu().apply {
+                    val colAtPoint = columnAtPoint(event.point)
+                    if (colAtPoint != -1 && getColumn(convertColumnIndexToModel(colAtPoint)).identifier == ThreadColumnIdentifier.MARK) {
+                        add(clearAllMarks)
+                    }
+
                     add(
                         JMenu("Filter all with same...").apply {
                             for (column in this@table.model.columns.filterableColumns) {
@@ -349,14 +351,22 @@ class MultiThreadView(
             }
         }
 
-        val sortButtons = ButtonGroup().apply {
-            val countDescButton = sortButton(NUMERIC_SORT_DESCENDING, "Sort by count (descending)", byCountDesc)
-            add(countDescButton)
-            setSelected(countDescButton.model, true)
-
-            add(sortButton(NUMERIC_SORT_ASCENDING, "Sort by count (ascending)", byCountAsc))
-            add(sortButton(NATURAL_SORT_ASCENDING, "Sort A-Z", byNameAsc))
-            add(sortButton(NATURAL_SORT_DESCENDING, "Sort Z-A", byNameDesc))
+        val sortButtons = ButtonGroup()
+
+        for ((i, sortAction) in stateList.sortActions.withIndex()) {
+            sortButtons.add(
+                JToggleButton(
+                    Action(
+                        description = sortAction.description,
+                        icon = sortAction.icon,
+                        selected = sortAction.selected,
+                    ) { e ->
+                        sortAction.actionPerformed(e)
+                        systemList.sortActions[i].actionPerformed(e)
+                        poolList.sortActions[i].actionPerformed(e)
+                    },
+                ),
+            )
         }
 
         add(JLabel("Version: ${threadDumps.first().version}"))
@@ -370,7 +380,7 @@ class MultiThreadView(
                     val sortGroupEnumeration = sortButtons.elements
                     add(sortGroupEnumeration.nextElement(), "split ${sortButtons.buttonCount}, flowx")
                     for (element in sortGroupEnumeration) {
-                        add(element)
+                        add(element, "gapx 2")
                     }
                     add(FlatScrollPane(stateList), "w 220, h 100!")
                     // if all the thread dumps are "unassigned", no need to add the system selector
@@ -393,19 +403,6 @@ class MultiThreadView(
 
     override val icon = MultiThreadViewer.icon
 
-    private fun sortButton(icon: Icon, description: String, comparator: FilterComparator): JToggleButton {
-        return JToggleButton(
-            Action(
-                description = description,
-                icon = icon,
-            ) {
-                stateList.model.comparator = comparator
-                poolList.model.comparator = comparator
-                systemList.model.comparator = comparator
-            },
-        )
-    }
-
     override fun customizePopupMenu(menu: JPopupMenu) {
         menu.addSeparator()
         menu.add(
@@ -427,11 +424,6 @@ class MultiThreadView(
     companion object {
         private val BACKGROUND = CoroutineScope(Dispatchers.Default)
 
-        private val NATURAL_SORT_ASCENDING = FlatSVGIcon("icons/bx-sort-a-z.svg")
-        private val NATURAL_SORT_DESCENDING = FlatSVGIcon("icons/bx-sort-z-a.svg")
-        private val NUMERIC_SORT_ASCENDING = FlatSVGIcon("icons/bx-sort-up.svg")
-        private val NUMERIC_SORT_DESCENDING = FlatSVGIcon("icons/bx-sort-down.svg")
-
         private fun List<ThreadDump?>.toLifespanList(): List<ThreadLifespan> {
             val idsToLifespans = mutableMapOf<Int, Array<Thread?>>()
             forEachIndexed { i, threadDump ->
@@ -485,11 +477,12 @@ class MultiThreadView(
     }
 }
 
-object MultiThreadViewer : MultiTool, ClipboardTool, PreferenceCategory {
+data object MultiThreadViewer : MultiTool, ClipboardTool, PreferenceCategory {
     override val title = "Thread Viewer"
     override val description = "Thread dump (.json or .txt) files"
     override val icon = FlatSVGIcon("icons/bx-file.svg")
     override val extensions = listOf("json", "txt")
+    override val respectsEncoding: Boolean = true
     override fun open(path: Path): ToolPanel = open(listOf(path))
     override fun open(paths: List<Path>): ToolPanel {
         return MultiThreadView(paths.sortedWith(compareBy(AlphanumComparator(), Path::name)))
@@ -520,5 +513,6 @@ object MultiThreadViewer : MultiTool, ClipboardTool, PreferenceCategory {
     )
 
     override val displayName: String = "Thread View"
+    override val key: String = "threadview"
     override val preferences = listOf(ShowNullThreads, ShowEmptyValues)
 }
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/thread/ThreadComparisonPane.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/thread/ThreadComparisonPane.kt
index 9611fb67..bae0b16b 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/thread/ThreadComparisonPane.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/thread/ThreadComparisonPane.kt
@@ -3,7 +3,7 @@ package io.github.inductiveautomation.kindling.thread
 import com.formdev.flatlaf.extras.FlatSVGIcon
 import com.formdev.flatlaf.extras.components.FlatButton
 import com.formdev.flatlaf.extras.components.FlatLabel
-import com.formdev.flatlaf.extras.components.FlatTextPane
+import com.jidesoft.swing.StyledLabel
 import io.github.inductiveautomation.kindling.core.DetailsPane
 import io.github.inductiveautomation.kindling.core.Kindling.Preferences.Advanced.HyperlinkStrategy
 import io.github.inductiveautomation.kindling.core.Kindling.Preferences.General.UseHyperlinks
@@ -18,19 +18,20 @@ import io.github.inductiveautomation.kindling.utils.add
 import io.github.inductiveautomation.kindling.utils.escapeHtml
 import io.github.inductiveautomation.kindling.utils.getAll
 import io.github.inductiveautomation.kindling.utils.jFrame
+import io.github.inductiveautomation.kindling.utils.style
 import io.github.inductiveautomation.kindling.utils.tag
 import io.github.inductiveautomation.kindling.utils.toBodyLine
 import net.miginfocom.swing.MigLayout
 import org.jdesktop.swingx.JXTaskPane
 import org.jdesktop.swingx.JXTaskPaneContainer
 import java.awt.Color
+import java.awt.Font
 import java.text.DecimalFormat
 import java.util.EventListener
 import javax.swing.JPanel
 import javax.swing.UIManager
 import javax.swing.event.EventListenerList
 import javax.swing.event.HyperlinkEvent
-import javax.swing.text.html.HTMLEditorKit
 import kotlin.properties.Delegates
 
 class ThreadComparisonPane(
@@ -88,7 +89,7 @@ class ThreadComparisonPane(
 
     private fun updateData() {
         threads.firstOrNull { it != null }?.let {
-            header.setText(it)
+            header.setThread(it)
         }
 
         val moreThanOneThread = threads.count { it != null } > 1
@@ -132,60 +133,34 @@ class ThreadComparisonPane(
         fun onBlockerSelected(threadId: Int)
     }
 
-    private class ComparisonEditorKit : HTMLEditorKit() {
-        init {
-            styleSheet.apply {
-                //language=CSS
-                addRule(
-                    """
-                b {
-                    font-size: larger;
-                }
-                pre { 
-                    font-size: 10px; 
-                }
-                object { 
-                    padding-left: 16px; 
-                }
-                    """.trimIndent(),
-                )
-            }
-        }
-    }
-
     private class HeaderPanel : JPanel(MigLayout("fill, ins 3")) {
-        private val nameLabel = FlatTextPane().apply {
-            editorKit = ComparisonEditorKit()
-            isEditable = false
+        private val nameLabel = StyledLabel().apply {
+            isLineWrap = false
         }
 
         init {
             add(nameLabel, "pushx, growx")
         }
 
-        fun setText(thread: Thread) {
-            nameLabel.text = buildString {
-                tag("html") {
-                    tag("b", thread.name)
-                    append("<br>")
-
-                    tag("b", "ID: ")
-                    append(thread.id)
-                    tag("b", " | ")
-
-                    tag("b", "Daemon: ")
-                    append(thread.isDaemon)
-                    tag("b", " | ")
-
-                    if (thread.system != null) {
-                        tag("b", "System: ")
-                        append(thread.system)
-                        tag("b", " | ")
-                    }
-                    if (thread.scope != null) {
-                        tag("b", "Scope: ")
-                        append(thread.scope)
-                    }
+        fun setThread(thread: Thread) {
+            nameLabel.style {
+                add(thread.name, Font.BOLD)
+                add("\n")
+                add("ID: ", Font.BOLD)
+                add(thread.id.toString())
+                add(" | ")
+                add("Daemon: ", Font.BOLD)
+                add(thread.isDaemon.toString())
+                add(" | ")
+
+                if (thread.system != null) {
+                    add("System: ", Font.BOLD)
+                    add(thread.system)
+                    add(" | ")
+                }
+                if (thread.scope != null) {
+                    add("Scope: ", Font.BOLD)
+                    add(thread.scope)
                 }
             }
         }
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/thread/model/ThreadDump.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/thread/model/ThreadDump.kt
index a3d06f02..0d2a20fb 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/thread/model/ThreadDump.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/thread/model/ThreadDump.kt
@@ -1,7 +1,7 @@
 package io.github.inductiveautomation.kindling.thread.model
 
+import io.github.inductiveautomation.kindling.core.Kindling.Preferences.General.DefaultEncoding
 import io.github.inductiveautomation.kindling.core.ToolOpeningException
-import io.github.inductiveautomation.kindling.utils.getLogger
 import io.github.inductiveautomation.kindling.utils.getValue
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
@@ -22,10 +22,8 @@ data class ThreadDump internal constructor(
             ignoreUnknownKeys = true
         }
 
-        private val logger = getLogger<ThreadDump>()
-
         fun fromStream(stream: InputStream): ThreadDump? {
-            val text = stream.reader().readText()
+            val text = stream.reader(DefaultEncoding.currentValue).readText()
             return try {
                 JSON.decodeFromString(serializer(), text)
             } catch (ex: SerializationException) {
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/thread/model/ThreadModel.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/thread/model/ThreadModel.kt
index 34fb8285..9aabd3d8 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/thread/model/ThreadModel.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/thread/model/ThreadModel.kt
@@ -146,8 +146,12 @@ class ThreadModel(val threadData: List<ThreadLifespan>) : AbstractTableModel() {
     override fun getColumnCount(): Int = columns.size
     override fun getValueAt(row: Int, column: Int): Any? = get(row, columns[column])
     override fun getColumnClass(column: Int): Class<*> = columns[column].clazz
+    operator fun get(row: Int): ThreadLifespan {
+        return threadData[row]
+    }
+
     operator fun <T> get(row: Int, column: Column<ThreadLifespan, T>): T {
-        return threadData[row].let { info ->
+        return get(row).let { info ->
             column.getValue(info)
         }
     }
@@ -164,7 +168,7 @@ class ThreadModel(val threadData: List<ThreadLifespan>) : AbstractTableModel() {
     }
 
     @Suppress("unused", "MemberVisibilityCanBePrivate")
-    object MultiThreadColumns : ThreadColumnList() {
+    data object MultiThreadColumns : ThreadColumnList() {
         private val MONOSPACED = Font(Font.MONOSPACED, Font.PLAIN, 13)
 
         val state = Column<ThreadLifespan, String>(
@@ -233,7 +237,7 @@ class ThreadModel(val threadData: List<ThreadLifespan>) : AbstractTableModel() {
     }
 
     @Suppress("unused", "MemberVisibilityCanBePrivate")
-    object SingleThreadColumns : ThreadColumnList() {
+    data object SingleThreadColumns : ThreadColumnList() {
         val state = Column<ThreadLifespan, ThreadState>(
             "State",
             columnCustomization = {
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/Action.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/Action.kt
index f35308ea..5456c4a7 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/Action.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/Action.kt
@@ -1,7 +1,6 @@
 package io.github.inductiveautomation.kindling.utils
 
 import java.awt.event.ActionEvent
-import java.awt.event.ActionListener
 import javax.swing.AbstractAction
 import javax.swing.Icon
 import javax.swing.KeyStroke
@@ -11,19 +10,21 @@ import kotlin.reflect.KProperty
 /**
  * More idiomatic Kotlin wrapper for AbstractAction.
  */
-class Action(
+open class Action(
     name: String? = null,
     description: String? = null,
     icon: Icon? = null,
     accelerator: KeyStroke? = null,
-    private val action: ActionListener,
+    selected: Boolean = false,
+    private val action: Action.(e: ActionEvent) -> Unit,
 ) : AbstractAction() {
     var name: String? by actionValue(NAME, name)
     var description: String? by actionValue(SHORT_DESCRIPTION, description)
     var icon: Icon? by actionValue(SMALL_ICON, icon)
     var accelerator: KeyStroke? by actionValue(ACCELERATOR_KEY, accelerator)
+    var selected: Boolean by actionValue(SELECTED_KEY, selected)
 
-    private fun <V> actionValue(name: String, initialValue: V) = object : ReadWriteProperty<AbstractAction, V> {
+    protected fun <V> actionValue(name: String, initialValue: V) = object : ReadWriteProperty<AbstractAction, V> {
         init {
             putValue(name, initialValue)
         }
@@ -38,5 +39,5 @@ class Action(
         }
     }
 
-    override fun actionPerformed(e: ActionEvent) = action.actionPerformed(e)
+    override fun actionPerformed(e: ActionEvent) = action(this, e)
 }
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/ColumnList.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/ColumnList.kt
index 9933d679..a0c47d7d 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/ColumnList.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/ColumnList.kt
@@ -36,7 +36,7 @@ abstract class ColumnList<R> private constructor(
         list.add(column)
     }
 
-    operator fun get(column: Column<R, *>): Int = indexOf(column)
+    operator fun get(column: Column<*, *>): Int = indexOf(column)
 
     fun toColumnFactory() = object : ColumnFactory() {
         override fun configureTableColumn(model: TableModel, columnExt: TableColumnExt) {
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/FilterList.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/FilterList.kt
new file mode 100644
index 00000000..3707ae08
--- /dev/null
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/FilterList.kt
@@ -0,0 +1,189 @@
+package io.github.inductiveautomation.kindling.utils
+
+import com.formdev.flatlaf.extras.FlatSVGIcon
+import com.jidesoft.comparator.AlphanumComparator
+import com.jidesoft.swing.CheckBoxList
+import com.jidesoft.swing.ListSearchable
+import io.github.inductiveautomation.kindling.core.Kindling.SECONDARY_ACTION_ICON_SCALE
+import io.github.inductiveautomation.kindling.utils.FilterComparator.ByCountDescending
+import java.text.DecimalFormat
+import javax.swing.AbstractListModel
+import javax.swing.ListModel
+
+data class FilterModelEntry(
+    val key: String?,
+    val count: Int,
+)
+
+enum class FilterComparator(
+    val tooltip: String,
+    val icon: FlatSVGIcon,
+    val comparator: Comparator<FilterModelEntry>,
+) : Comparator<FilterModelEntry> by comparator {
+    ByNameAscending(
+        tooltip = "Sort A-Z",
+        icon = FlatSVGIcon("icons/bx-sort-a-z.svg").derive(SECONDARY_ACTION_ICON_SCALE),
+        comparator = compareBy(nullsFirst(AlphanumComparator(false))) { it.key },
+    ),
+    ByNameDescending(
+        tooltip = "Sort Z-A",
+        icon = FlatSVGIcon("icons/bx-sort-z-a.svg").derive(SECONDARY_ACTION_ICON_SCALE),
+        comparator = ByNameAscending.reversed(),
+    ),
+    ByCountAscending(
+        tooltip = "Sort by Count",
+        icon = FlatSVGIcon("icons/bx-sort-up.svg").derive(SECONDARY_ACTION_ICON_SCALE),
+        comparator = compareBy(FilterModelEntry::count),
+    ),
+    ByCountDescending(
+        tooltip = "Sort by Count (descending)",
+        icon = FlatSVGIcon("icons/bx-sort-down.svg").derive(SECONDARY_ACTION_ICON_SCALE),
+        comparator = ByCountAscending.reversed(),
+    ),
+    ;
+}
+
+fun FilterModel(data: Map<String?, Int>) = FilterModel(data) { it }
+
+class FilterModel<T>(
+    val data: Map<T, Int>,
+    val sortKey: (T) -> String?,
+) : AbstractListModel<Any>() {
+    private val total = data.values.sum()
+    val percentages = data.mapValues { (_, count) ->
+        val percentage = count.toFloat() / total
+        percentFormat.format(percentage)
+    }
+
+    internal var values: List<*> = data.keys.toList()
+
+    override fun getSize(): Int = values.size + 1
+    override fun getElementAt(index: Int): Any? {
+        return if (index == 0) {
+            CheckBoxList.ALL_ENTRY
+        } else {
+            values[index - 1]
+        }
+    }
+
+    fun indexOf(value: Any?): Int {
+        val indexOf: Int = values.indexOf(value)
+        return if (indexOf >= 0) {
+            indexOf + 1
+        } else {
+            -1
+        }
+    }
+
+    fun copy(comparator: FilterComparator): FilterModel<T> = FilterModel(
+        data.entries
+            .sortedWith(
+                compareBy(comparator) { (key, value) ->
+                    FilterModelEntry(sortKey(key), value)
+                },
+            )
+            .associate(Map.Entry<T, Int>::toPair),
+        sortKey,
+    )
+
+    companion object {
+        private val percentFormat = DecimalFormat.getPercentInstance()
+    }
+}
+
+typealias Stringifier = (Any?) -> String?
+
+class FilterList(
+    initialComparator: FilterComparator = ByCountDescending,
+    private val tooltipToStringFn: Stringifier? = null,
+    private val toStringFn: Stringifier = { it?.toString() },
+) : CheckBoxList(FilterModel(emptyMap())) {
+    private var lastSelection = arrayOf<Any>()
+
+    init {
+        selectionModel = NoSelectionModel()
+        isClickInCheckBoxOnly = false
+
+        cellRenderer = listCellRenderer<Any?> { _, value, _, _, _ ->
+            when (value) {
+                ALL_ENTRY -> {
+                    text = value.toString()
+                }
+
+                else -> {
+                    text = "${toStringFn(value)} [${model.data[value]}] (${model.percentages[value]})"
+                    toolTipText = tooltipToStringFn?.let { stringifier ->
+                        "${stringifier(value)} [${model.data[value]}] (${model.percentages[value]})"
+                    } ?: text
+                }
+            }
+        }
+
+        object : ListSearchable(this) {
+            init {
+                isCaseSensitive = false
+                isRepeats = true
+                isCountMatch = true
+            }
+
+            override fun convertElementToString(element: Any?): String = element.toString()
+
+            override fun setSelectedIndex(index: Int, incremental: Boolean) {
+                checkBoxListSelectedIndex = index
+            }
+        }
+    }
+
+    fun select(value: Any?) {
+        val rowToSelect = model.indexOf(value)
+        checkBoxListSelectionModel.setSelectionInterval(rowToSelect, rowToSelect)
+    }
+
+    var comparator: FilterComparator = initialComparator
+        set(newComparator) {
+            model = model.copy(newComparator)
+            field = newComparator
+        }
+
+    @Suppress("UNCHECKED_CAST")
+    override fun getModel(): FilterModel<in Any?> = super.getModel() as FilterModel<in Any?>
+
+    override fun setModel(model: ListModel<*>) {
+        require(model is FilterModel<*>)
+        val currentSelection = checkBoxListSelectedValues
+        lastSelection = if (currentSelection.isEmpty()) {
+            lastSelection
+        } else {
+            currentSelection
+        }
+
+        try {
+            checkBoxListSelectionModel.valueIsAdjusting = true
+
+            super.setModel(model)
+
+            for (sortAction in sortActions) {
+                sortAction.selected = comparator == sortAction.comparator
+            }
+            addCheckBoxListSelectedValues(lastSelection)
+        } finally {
+            checkBoxListSelectionModel.valueIsAdjusting = false
+        }
+    }
+
+    val sortActions: List<SortAction> = FilterComparator.entries.map { filterComparator ->
+        SortAction(filterComparator)
+    }
+
+    inner class SortAction(comparator: FilterComparator) : Action(
+        description = comparator.tooltip,
+        icon = comparator.icon,
+        selected = this@FilterList.comparator == comparator,
+        action = {
+            this@FilterList.comparator = comparator
+            selected = true
+        },
+    ) {
+        var comparator: FilterComparator by actionValue("filterComparator", comparator)
+    }
+}
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/General.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/General.kt
index b2f793e6..2219a63e 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/General.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/General.kt
@@ -62,6 +62,12 @@ fun StringBuilder.tag(tag: String, content: String) {
  */
 fun <T> Grouping<T, Int>.mode(): Int? = eachCount().maxOfOrNull { it.key }
 
+fun <T, U : Comparable<U>> List<T>.isSortedBy(keyFn: (T) -> U): Boolean {
+    return asSequence().zipWithNext { a, b ->
+        keyFn(a) <= keyFn(b)
+    }.all { it }
+}
+
 val JDBCType.javaType: Class<*>
     get() = when (this) {
         JDBCType.BIT -> Boolean::class
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/Serializers.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/Serializers.kt
index c725dd5b..188d6b5e 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/Serializers.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/Serializers.kt
@@ -8,6 +8,7 @@ import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
+import java.nio.charset.Charset
 import java.nio.file.Path
 import java.time.ZoneId
 import kotlin.io.path.Path
@@ -47,3 +48,11 @@ object ZoneIdSerializer : KSerializer<ZoneId> {
 
     override fun serialize(encoder: Encoder, value: ZoneId) = encoder.encodeString(value.id)
 }
+
+object CharsetSerializer : KSerializer<Charset> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor(Charset::class.java.name, PrimitiveKind.STRING)
+
+    override fun deserialize(decoder: Decoder): Charset = Charset.forName(decoder.decodeString())
+
+    override fun serialize(encoder: Encoder, value: Charset) = encoder.encodeString(value.name())
+}
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/StackTrace.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/StackTrace.kt
index 972dd5d8..9343b234 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/StackTrace.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/StackTrace.kt
@@ -61,7 +61,7 @@ enum class MajorVersion(val version: String) {
 
         fun lookup(version: String): MajorVersion? {
             return versionCache.getOrPut(version) {
-                values().firstOrNull { majorVersion ->
+                entries.firstOrNull { majorVersion ->
                     version.startsWith(majorVersion.version)
                 }
             }
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/Swing.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/Swing.kt
index 31caaea7..6aef15c2 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/Swing.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/Swing.kt
@@ -2,7 +2,7 @@ package io.github.inductiveautomation.kindling.utils
 
 import com.formdev.flatlaf.extras.FlatSVGIcon
 import com.formdev.flatlaf.extras.components.FlatScrollPane
-import com.jidesoft.swing.ListSearchable
+import com.formdev.flatlaf.util.SystemInfo
 import com.jidesoft.swing.StyledLabel
 import com.jidesoft.swing.StyledLabelBuilder
 import io.github.evanrupert.excelkt.workbook
@@ -22,6 +22,8 @@ import org.jdesktop.swingx.sort.SortController
 import org.jdesktop.swingx.table.ColumnControlButton
 import java.awt.Color
 import java.awt.Component
+import java.awt.Container
+import java.awt.Toolkit
 import java.awt.event.MouseAdapter
 import java.awt.event.MouseEvent
 import java.io.File
@@ -41,7 +43,11 @@ import javax.swing.JPopupMenu
 import javax.swing.JTable
 import javax.swing.JTree
 import javax.swing.ListCellRenderer
+import javax.swing.SortOrder.ASCENDING
+import javax.swing.SortOrder.DESCENDING
+import javax.swing.SortOrder.UNSORTED
 import javax.swing.UIManager
+import javax.swing.border.EmptyBorder
 import javax.swing.event.EventListenerList
 import javax.swing.filechooser.FileFilter
 import javax.swing.plaf.basic.BasicComboBoxRenderer
@@ -52,6 +58,7 @@ import javax.swing.tree.TreeCellRenderer
 import javax.swing.tree.TreeNode
 import kotlin.reflect.KClass
 import kotlin.reflect.safeCast
+import kotlin.time.Duration.Companion.milliseconds
 
 typealias StringProvider<T> = (T?) -> String?
 typealias IconProvider<T> = (T?) -> Icon?
@@ -135,8 +142,12 @@ inline fun <reified T> listCellRenderer(crossinline customize: JLabel.(list: JLi
             focused: Boolean,
         ): Component {
             return super.getListCellRendererComponent(list, value, index, selected, focused).apply {
-                if (value is T) {
-                    customize.invoke(this as JLabel, list, value, index, selected, focused)
+                try {
+                    if (value is T) {
+                        customize.invoke(this as JLabel, list, value, index, selected, focused)
+                    }
+                } catch (e: Exception) {
+                    e.printStackTrace()
                 }
             }
         }
@@ -203,18 +214,6 @@ fun FlatSVGIcon.derive(colorer: (Color) -> Color): FlatSVGIcon {
     }
 }
 
-fun JList<*>.installSearchable(setup: ListSearchable.() -> Unit, conversion: (Any?) -> String): ListSearchable {
-    return object : ListSearchable(this) {
-        init {
-            setup()
-        }
-
-        override fun convertElementToString(element: Any?): String {
-            return element.let(conversion)
-        }
-    }
-}
-
 class NoSelectionModel : DefaultListSelectionModel() {
     override fun setSelectionInterval(index0: Int, index1: Int) = Unit
     override fun addSelectionInterval(index0: Int, index1: Int) = Unit
@@ -239,6 +238,12 @@ class ReifiedJXTable<T : TableModel>(
 ) : JXTable(model) {
     private val setup = true
 
+    private val packLater: () -> Unit = debounce(
+        waitTime = 500.milliseconds,
+        coroutineScope = EDT_SCOPE,
+        destinationFunction = ::packAll,
+    )
+
     init {
         if (columns != null) {
             columnFactory = columns.toColumnFactory()
@@ -251,6 +256,8 @@ class ReifiedJXTable<T : TableModel>(
             getTooltip = { it },
         )
 
+        setSortOrderCycle(ASCENDING, DESCENDING, UNSORTED)
+
         // TODO header name as tooltip without breaking sorting
 
         addHighlighter(
@@ -259,12 +266,12 @@ class ReifiedJXTable<T : TableModel>(
             },
         )
 
-        packAll()
+        packLater()
         actionMap.remove("find")
     }
 
     override fun createDefaultColumnControl(): JComponent {
-        return ColumnControlButton(this, FlatSVGIcon("icons/bx-column.svg").derive(0.5F))
+        return ColumnControlButton(this, FlatSVGIcon("icons/bx-column.svg").derive(0.8F))
     }
 
     @Suppress("UNCHECKED_CAST")
@@ -279,13 +286,23 @@ class ReifiedJXTable<T : TableModel>(
 
         val sortOrder = if (sortedColumn >= 0) (rowSorter as SortController<*>).getSortOrder(sortedColumn) else null
 
+        val previousColumnSizes = IntArray(columnCount) { i ->
+            getColumnExt(i).preferredWidth
+        }
+
         super.setModel(model)
 
         if (sortOrder != null && sortedColumnIsVisible) {
             setSortOrder(sortedColumn, sortOrder)
         }
         if (setup) {
-            packAll()
+            for (index in 0 until columnCount) {
+                val previousSize = previousColumnSizes.getOrNull(index)
+                if (previousSize != null) {
+                    getColumnExt(index).preferredWidth = previousSize
+                }
+            }
+            packLater()
         }
     }
 
@@ -360,9 +377,17 @@ inline fun jFrame(
     width: Int,
     height: Int,
     initiallyVisible: Boolean = true,
+    embedContentIntoTitleBar: Boolean = false,
     block: JFrame.() -> Unit,
 ) = JFrame(title).apply {
     setSize(width, height)
+
+    if (embedContentIntoTitleBar && SystemInfo.isMacFullWindowContentSupported) {
+        rootPane.putClientProperty("apple.awt.windowTitleVisible", false)
+        rootPane.putClientProperty("apple.awt.fullWindowContent", true)
+        rootPane.putClientProperty("apple.awt.transparentTitleBar", true)
+    }
+
     iconImage = frameIcon
     defaultCloseOperation = JFrame.DISPOSE_ON_CLOSE
 
@@ -395,6 +420,16 @@ inline fun StyledLabel(block: StyledLabelBuilder.() -> Unit): StyledLabel {
     return StyledLabelBuilder().apply(block).createLabel()
 }
 
+inline fun StyledLabel.style(block: StyledLabelBuilder.() -> Unit) {
+    StyledLabelBuilder().apply {
+        block()
+        clearStyleRanges()
+        configure(this@style)
+    }
+}
+
+fun EmptyBorder(): EmptyBorder = EmptyBorder(0, 0, 0, 0)
+
 val TableModel.rowIndices get() = 0 until rowCount
 val TableModel.columnIndices get() = 0 until columnCount
 
@@ -440,3 +475,15 @@ fun TableModel.exportToXLSX(file: File) = file.outputStream().use { fos ->
         }
     }.xssfWorkbook.write(fos)
 }
+
+fun Component.traverseChildren(): Sequence<Component> = sequence {
+    if (this@traverseChildren is Container) {
+        val childComponents = synchronized(treeLock) { components.copyOf() }
+        for (component in childComponents) {
+            yield(component)
+            yieldAll(component.traverseChildren())
+        }
+    }
+}
+
+val menuShortcutKeyMaskEx = Toolkit.getDefaultToolkit().menuShortcutKeyMaskEx
diff --git a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/TabStrip.kt b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/TabStrip.kt
index 469a4083..aa70c5a1 100644
--- a/src/main/kotlin/io/github/inductiveautomation/kindling/utils/TabStrip.kt
+++ b/src/main/kotlin/io/github/inductiveautomation/kindling/utils/TabStrip.kt
@@ -6,6 +6,7 @@ import java.awt.Component
 import java.awt.Container
 import java.awt.event.ComponentAdapter
 import java.awt.event.ComponentEvent
+import java.awt.event.ComponentListener
 import javax.swing.Icon
 import javax.swing.JComponent
 import javax.swing.JFrame
@@ -21,7 +22,7 @@ interface PopupMenuCustomizer {
 interface FloatableComponent {
     val icon: Icon?
     val tabName: String
-    val tabTooltip: String
+    val tabTooltip: String?
 }
 
 class TabStrip : FlatTabbedPane() {
@@ -42,40 +43,42 @@ class TabStrip : FlatTabbedPane() {
             val tab = getComponentAt(tabIndex) as JComponent
 
             JPopupMenu().apply {
-                add(
-                    Action("Close") {
-                        removeClosableTabAt(tabIndex)
-                    },
-                )
-                add(
-                    Action("Close Other Tabs") {
-                        for (i in tabCount - 1 downTo 0) {
-                            if (i != tabIndex) {
+                if (isTabsClosable) {
+                    add(
+                        Action("Close") {
+                            removeClosableTabAt(tabIndex)
+                        },
+                    )
+                    add(
+                        Action("Close Other Tabs") {
+                            for (i in tabCount - 1 downTo 0) {
+                                if (i != tabIndex) {
+                                    removeClosableTabAt(i)
+                                }
+                            }
+                        },
+                    )
+                    add(
+                        Action("Close Tabs Left") {
+                            for (i in tabIndex - 1 downTo 0) {
                                 removeClosableTabAt(i)
                             }
-                        }
-                    },
-                )
-                add(
-                    Action("Close Tabs Left") {
-                        for (i in tabIndex - 1 downTo 0) {
-                            removeClosableTabAt(i)
-                        }
-                    },
-                )
-                add(
-                    Action("Close Tabs Right") {
-                        for (i in tabCount - 1 downTo tabIndex + 1) {
-                            removeClosableTabAt(i)
-                        }
-                    },
-                )
-                val closable = isTabClosable(tabIndex)
-                add(
-                    Action(if (closable) "Pin" else "Unpin") {
-                        setTabClosable(tabIndex, !closable)
-                    },
-                )
+                        },
+                    )
+                    add(
+                        Action("Close Tabs Right") {
+                            for (i in tabCount - 1 downTo tabIndex + 1) {
+                                removeClosableTabAt(i)
+                            }
+                        },
+                    )
+                    val closable = isTabClosable(tabIndex)
+                    add(
+                        Action(if (closable) "Pin" else "Unpin") {
+                            setTabClosable(tabIndex, !closable)
+                        },
+                    )
+                }
                 if (tab is FloatableComponent) {
                     add(
                         Action("Float") {
@@ -122,26 +125,37 @@ class TabStrip : FlatTabbedPane() {
         addTab(
             tabName.truncate(30),
             icon,
-            LazyTab(component),
+            LazyTab(tabName, icon, tabTooltip, component),
             tabTooltip,
         )
     }
 
-    private class LazyTab(supplier: () -> Component) : JPanel(BorderLayout()) {
-        private var initialized = false
+    open class LazyTab(
+        override val tabName: String,
+        override val icon: Icon?,
+        override val tabTooltip: String?,
+        supplier: () -> Component,
+    ) : JPanel(BorderLayout()), PopupMenuCustomizer, FloatableComponent {
+        val component = lazy(supplier)
 
         init {
             addComponentListener(
                 object : ComponentAdapter() {
                     override fun componentShown(e: ComponentEvent) {
-                        if (!initialized) {
-                            add(supplier(), BorderLayout.CENTER)
-                            initialized = true
+                        if (!component.isInitialized()) {
+                            val actualComponent = component.value
+                            add(actualComponent, BorderLayout.CENTER)
                         }
                     }
                 },
             )
         }
+
+        final override fun addComponentListener(l: ComponentListener) = super.addComponentListener(l)
+
+        override fun customizePopupMenu(menu: JPopupMenu) {
+            (component.value as? PopupMenuCustomizer)?.customizePopupMenu(menu)
+        }
     }
 
     private fun <T> createPopupFrame(tab: T): JFrame where T : Container, T : FloatableComponent {
diff --git a/src/main/resources/icons/bx-block.svg b/src/main/resources/icons/bx-block.svg
new file mode 100644
index 00000000..e5e5c1f6
--- /dev/null
+++ b/src/main/resources/icons/bx-block.svg
@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="#6E6E6E">
+    <path d="M12 2C6.486 2 2 6.486 2 12s4.486 10 10 10 10-4.486 10-10S17.514 2 12 2zM4 12c0-1.846.634-3.542 1.688-4.897l11.209 11.209A7.946 7.946 0 0 1 12 20c-4.411 0-8-3.589-8-8zm14.312 4.897L7.103 5.688A7.948 7.948 0 0 1 12 4c4.411 0 8 3.589 8 8a7.954 7.954 0 0 1-1.688 4.897z"/>
+</svg>
diff --git a/src/main/resources/icons/bx-minus.svg b/src/main/resources/icons/bx-minus.svg
new file mode 100644
index 00000000..0f7e8192
--- /dev/null
+++ b/src/main/resources/icons/bx-minus.svg
@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="#6E6E6E">
+    <path d="M5 11h14v2H5z"/>
+</svg>
diff --git a/src/main/resources/icons/bx-plus.svg b/src/main/resources/icons/bx-plus.svg
new file mode 100644
index 00000000..54904a24
--- /dev/null
+++ b/src/main/resources/icons/bx-plus.svg
@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill='#6E6E6E'>
+    <path d="M19 11h-6V5h-2v6H5v2h6v6h2v-6h6z"/>
+</svg>
diff --git a/src/main/resources/icons/bx-x.svg b/src/main/resources/icons/bx-x.svg
new file mode 100644
index 00000000..beeaaf82
--- /dev/null
+++ b/src/main/resources/icons/bx-x.svg
@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="#6E6E6E">
+    <path d="m16.192 6.344-4.243 4.242-4.242-4.242-1.414 1.414L10.535 12l-4.242 4.242 1.414 1.414 4.242-4.242 4.243 4.242 1.414-1.414L13.364 12l4.242-4.242z"/>
+</svg>
diff --git a/src/test/kotlin/io/github/inductiveautomation/kindling/log/WrapperLogParsingTests.kt b/src/test/kotlin/io/github/inductiveautomation/kindling/log/WrapperLogParsingTests.kt
index 85689afc..8f4e81f6 100644
--- a/src/test/kotlin/io/github/inductiveautomation/kindling/log/WrapperLogParsingTests.kt
+++ b/src/test/kotlin/io/github/inductiveautomation/kindling/log/WrapperLogParsingTests.kt
@@ -163,7 +163,7 @@ class WrapperLogParsingTests : FunSpec(
 ) {
     companion object {
         fun parse(logs: String): List<WrapperLogEvent> {
-            return LogPanel.parseLogs(logs.trimIndent().lineSequence())
+            return WrapperLogView.parseLogs(logs.trimIndent().lineSequence())
         }
     }
 }