diff --git a/src/view/src/compute/rocprofvis_compute_roofline.cpp b/src/view/src/compute/rocprofvis_compute_roofline.cpp
index 2c1af1afb..acc964f76 100644
--- a/src/view/src/compute/rocprofvis_compute_roofline.cpp
+++ b/src/view/src/compute/rocprofvis_compute_roofline.cpp
@@ -51,6 +51,8 @@ constexpr const char* DISPLAY_NAMES_KERNEL_INTENSITY[] = {
     "L1 Intensity",   // kRPVControllerRooflineKernelIntensityTypeL1
     "LDS Intensity",  // kRPVControllerRooflineKernelIntensityTypeLDS
 };
+constexpr const char* MEMORY_LEVEL_NAMES[] = { "HBM", "L2", "L1", "LDS" };
+constexpr const char* FILTER_OPTION_ALL    = "All";
 constexpr const char* DISPLAY_NAMES_PRESET[] = {
     "FP4",   // PresetModel::Type::FP4
     "FP6",   // PresetModel::Type::FP6
@@ -70,6 +72,8 @@ Roofline::Roofline(DataProvider& data_provider, KernelMode kernel_mode)
 , m_menus_placement(InsideTopRight)
 , m_scale_intensity(true)
 , m_line_thickness(LINE_THICKNESS_DEFAULT)
+, m_active_preset(PresetModel::FP32)
+, m_memory_peak_filter(std::nullopt)
 , m_menus_rendered_height(0.0f)
 , m_hovered_item_distance(FLT_MAX)
 , m_workload_changed(false)
@@ -81,6 +85,8 @@ Roofline::Roofline(DataProvider& data_provider, KernelMode kernel_mode)
 , m_requested_workload_id(0)
 , m_kernel(nullptr)
 , m_requested_kernel_id(0)
+, m_isolated_kernel(nullptr)
+, m_isolated_bandwidth(std::nullopt)
 {
     m_widget_name = GenUniqueName("roofline");
     m_items.resize(static_cast<size_t>(__KRPVControllerRooflineCeilingComputeTypeLast +
@@ -120,6 +126,10 @@ Roofline::Update()
 {
     if(m_workload_changed)
     {
+        // Kernel pointers are rebuilt below, so drop any stale filters.
+        m_isolated_kernel    = nullptr;
+        m_isolated_bandwidth = std::nullopt;
+        m_memory_peak_filter = std::nullopt;
         m_workload =
             m_data_provider.ComputeModel().GetWorkload(m_requested_workload_id);
         if(m_workload)
@@ -253,6 +263,41 @@ Roofline::Update()
                             static_cast<double>(kernel_duration_scale)) });
                 }
             }
+            // Build filter dropdown options from what the workload actually has;
+            // empty memory levels should not be offered.
+            m_available_intensities.clear();
+            m_available_bandwidths.clear();
+            bool intensity_present[IM_ARRAYSIZE(MEMORY_LEVEL_NAMES)] = {};
+            for(const std::pair<const uint32_t, KernelInfo>& kernel : m_workload->kernels)
+            {
+                for(const std::pair<
+                        const rocprofvis_controller_roofline_kernel_intensity_type_t,
+                        KernelInfo::Roofline::Intensity>& intensity :
+                    kernel.second.roofline.intensities)
+                {
+                    intensity_present[intensity.second.type] = true;
+                }
+            }
+            for(uint32_t i = 0; i < IM_ARRAYSIZE(MEMORY_LEVEL_NAMES); i++)
+            {
+                if(intensity_present[i])
+                {
+                    m_available_intensities.emplace_back(
+                        static_cast<
+                            rocprofvis_controller_roofline_kernel_intensity_type_t>(i));
+                }
+            }
+            for(uint32_t i = __KRPVControllerRooflineCeilingBandwidthTypeFirst;
+                i < __KRPVControllerRooflineCeilingBandwidthTypeLast; i++)
+            {
+                rocprofvis_controller_roofline_ceiling_bandwidth_type_t bandwidth =
+                    static_cast<rocprofvis_controller_roofline_ceiling_bandwidth_type_t>(
+                        i);
+                if(m_workload->roofline.ceiling_bandwidth.count(bandwidth) > 0)
+                {
+                    m_available_bandwidths.emplace_back(bandwidth);
+                }
+            }
             ApplyPreset(PresetModel::FP32);
         }
         m_workload_changed = false;
@@ -264,6 +309,7 @@ Roofline::Update()
         {
             m_kernel = &m_workload->kernels.at(m_requested_kernel_id);
         }
+        RecomputeVisibility();
         m_kernel_changed = false;
     }
     if(m_options_changed)
@@ -333,6 +379,15 @@ Roofline::Render()
                       ImGuiChildFlags_Borders |
                           ImGuiChildFlags_AlwaysUseWindowPadding);
     SectionTitle("Roofline Analysis");
+    bool has_roofline =
+        m_workload && !m_workload->roofline.ceiling_bandwidth.empty() &&
+        !m_workload->roofline.ceiling_compute.empty() &&
+        !(m_kernel_mode == SingleKernel &&
+          (!m_kernel || m_kernel->roofline.intensities.empty()));
+    if(has_roofline)
+    {
+        RenderToolbar();
+    }
     ImGui::BeginChild("roofline");
     const ImVec2       region     = ImGui::GetContentRegionAvail();
     const ImGuiStyle&  style      = ImGui::GetStyle();
@@ -434,9 +489,7 @@ Roofline::Render()
                     }
                     case ItemModel::Type::Intensity:
                     {
-                        display =
-                            m_items[i].info.intensity &&
-                            (m_kernel ? m_items[i].parent_info.kernel == m_kernel : true);
+                        display = m_items[i].info.intensity;
                     }
                 }
                 display &= m_items[i].visible;
@@ -602,7 +655,29 @@ Roofline::Render()
         }
         bool menus_item_hovered = false;
         RenderMenus(region, plot_pos, plot_size, style, plot_style, menus_item_hovered);
-        if(!m_plot_zoom_enabled && roofline_hovered &&
+        bool dot_hovered =
+            !menus_item_hovered && m_kernel_mode == AllKernels && m_hovered_item_idx &&
+            m_items[m_hovered_item_idx.value()].type == ItemModel::Type::Intensity;
+        bool bandwidth_line_hovered =
+            !menus_item_hovered && m_hovered_item_idx &&
+            m_items[m_hovered_item_idx.value()].type ==
+                ItemModel::Type::CeilingBandwidth;
+        // Drag check so panning a zoomed plot is not treated as a click.
+        if(roofline_hovered && IsMouseReleasedWithDragCheck(ImGuiMouseButton_Left))
+        {
+            if(dot_hovered)
+            {
+                ToggleKernelIsolation(
+                    m_items[m_hovered_item_idx.value()].parent_info.kernel);
+            }
+            else if(bandwidth_line_hovered)
+            {
+                ToggleBandwidthIsolation(
+                    m_items[m_hovered_item_idx.value()].subtype.bandwidth);
+            }
+        }
+        if(!m_plot_zoom_enabled && roofline_hovered && !dot_hovered &&
+           !bandwidth_line_hovered && !menus_item_hovered &&
            ImGui::IsMouseClicked(ImGuiMouseButton_Left))
         {
             m_plot_zoom_enabled = true;
@@ -641,6 +716,176 @@ Roofline::SetKernel(uint32_t id)
     m_kernel_changed      = true;
 }
 
+void
+Roofline::RenderToolbar()
+{
+    const ImGuiStyle& style = ImGui::GetStyle();
+    int               count = 1;  // Compute peak is always present.
+    if(!m_available_bandwidths.empty())
+    {
+        count++;
+    }
+    if(m_kernel_mode == AllKernels)
+    {
+        count++;
+    }
+    if(!m_available_intensities.empty())
+    {
+        count++;
+    }
+    float cell = (ImGui::GetContentRegionAvail().x -
+                  style.ItemSpacing.x * static_cast<float>(count - 1)) /
+                 static_cast<float>(count);
+    cell = std::max(cell, ImGui::GetFontSize() * 4.0f);
+
+    // Draw "<label>" to the left, then size the next combo to fill the cell.
+    auto label_cell = [&](const char* label) {
+        ImGui::AlignTextToFramePadding();
+        ImGui::TextUnformatted(label);
+        ImGui::SameLine();
+        float combo_width = cell - ImGui::GetItemRectSize().x - style.ItemSpacing.x;
+        ImGui::SetNextItemWidth(std::max(combo_width, ImGui::GetFontSize() * 2.0f));
+    };
+
+    // Compute peak (preset)...
+    ImGui::BeginGroup();
+    ImGui::PushID("compute_peak");
+    label_cell("Compute peak");
+    PushComboStyles();
+    if(ImGui::BeginCombo("##compute_peak", DISPLAY_NAMES_PRESET[m_active_preset]))
+    {
+        for(PresetModel& preset : m_presets)
+        {
+            if(!preset.item_indices.empty() &&
+               ImGui::Selectable(DISPLAY_NAMES_PRESET[preset.type],
+                                 preset.type == m_active_preset))
+            {
+                ApplyPreset(preset.type);
+            }
+        }
+        ImGui::EndCombo();
+    }
+    PopComboStyles();
+    ImGui::PopID();
+    ImGui::EndGroup();
+
+    // Bandwidth peak...
+    if(!m_available_bandwidths.empty())
+    {
+        ImGui::SameLine();
+        ImGui::BeginGroup();
+        ImGui::PushID("bandwidth_peak");
+        label_cell("Bandwidth peak");
+        PushComboStyles();
+        if(ImGui::BeginCombo("##bandwidth_peak",
+                             m_isolated_bandwidth
+                                 ? MEMORY_LEVEL_NAMES[m_isolated_bandwidth.value()]
+                                 : FILTER_OPTION_ALL))
+        {
+            if(ImGui::Selectable(FILTER_OPTION_ALL, !m_isolated_bandwidth))
+            {
+                m_isolated_bandwidth = std::nullopt;
+                RecomputeVisibility();
+            }
+            for(rocprofvis_controller_roofline_ceiling_bandwidth_type_t bandwidth :
+                m_available_bandwidths)
+            {
+                if(ImGui::Selectable(MEMORY_LEVEL_NAMES[bandwidth],
+                                     m_isolated_bandwidth &&
+                                         m_isolated_bandwidth.value() == bandwidth))
+                {
+                    m_isolated_bandwidth = bandwidth;
+                    RecomputeVisibility();
+                }
+            }
+            ImGui::EndCombo();
+        }
+        PopComboStyles();
+        ImGui::PopID();
+        ImGui::EndGroup();
+    }
+
+    // Kernel (workload roofline only)...
+    if(m_kernel_mode == AllKernels)
+    {
+        ImGui::SameLine();
+        ImGui::BeginGroup();
+        ImGui::PushID("kernel");
+        label_cell("Kernel");
+        PushComboStyles();
+        if(ImGui::BeginCombo("##kernel",
+                             m_isolated_kernel ? m_isolated_kernel->name.c_str()
+                                               : FILTER_OPTION_ALL))
+        {
+            if(ImGui::Selectable(FILTER_OPTION_ALL, !m_isolated_kernel))
+            {
+                m_isolated_kernel = nullptr;
+                RecomputeVisibility();
+            }
+            for(const KernelInfo* kernel : m_workload->ordered_kernels)
+            {
+                // Kernels without roofline data do not belong in this list.
+                if(kernel->roofline.intensities.empty())
+                {
+                    continue;
+                }
+                // Long/mangled names: elide so the popup stays the toolbar width.
+                ImGui::PushID(kernel);
+                ImVec2 pos     = ImGui::GetCursorPos();
+                bool   clicked = ImGui::Selectable("", m_isolated_kernel == kernel);
+                ImGui::SetCursorPos(pos);
+                ElidedText(kernel->name.c_str(), ImGui::GetContentRegionAvail().x, cell);
+                if(clicked)
+                {
+                    m_isolated_kernel = kernel;
+                    RecomputeVisibility();
+                }
+                ImGui::PopID();
+            }
+            ImGui::EndCombo();
+        }
+        PopComboStyles();
+        ImGui::PopID();
+        ImGui::EndGroup();
+    }
+
+    // Kernel bandwidth (intensity memory level)...
+    if(!m_available_intensities.empty())
+    {
+        ImGui::SameLine();
+        ImGui::BeginGroup();
+        ImGui::PushID("kernel_bandwidth");
+        label_cell("Kernel bandwidth");
+        PushComboStyles();
+        if(ImGui::BeginCombo("##kernel_bandwidth",
+                             m_memory_peak_filter
+                                 ? MEMORY_LEVEL_NAMES[m_memory_peak_filter.value()]
+                                 : FILTER_OPTION_ALL))
+        {
+            if(ImGui::Selectable(FILTER_OPTION_ALL, !m_memory_peak_filter))
+            {
+                m_memory_peak_filter = std::nullopt;
+                RecomputeVisibility();
+            }
+            for(rocprofvis_controller_roofline_kernel_intensity_type_t level :
+                m_available_intensities)
+            {
+                if(ImGui::Selectable(MEMORY_LEVEL_NAMES[level],
+                                     m_memory_peak_filter &&
+                                         m_memory_peak_filter.value() == level))
+                {
+                    m_memory_peak_filter = level;
+                    RecomputeVisibility();
+                }
+            }
+            ImGui::EndCombo();
+        }
+        PopComboStyles();
+        ImGui::PopID();
+        ImGui::EndGroup();
+    }
+}
+
 void
 Roofline::RenderMenus(ImVec2 region, ImVec2 plot_pos, ImVec2 plot_size,
                        const ImGuiStyle& style, const ImPlotStyle& plot_style,
@@ -770,18 +1015,6 @@ Roofline::RenderMenus(ImVec2 region, ImVec2 plot_pos, ImVec2 plot_size,
         ImGui::BeginGroup();
         if(m_menus_mode == Options)
         {
-            ImGui::SeparatorText("Presets");
-            for(PresetModel& preset : m_presets)
-            {
-                if(!preset.item_indices.empty())
-                {
-                    if(ImGui::Button(DISPLAY_NAMES_PRESET[preset.type],
-                                     ImVec2(-1.0f, 0.0f)))
-                    {
-                        ApplyPreset(preset.type);
-                    }
-                }
-            }
             ImGui::SeparatorText("Custom");
         }
         ImGui::EndGroup();
@@ -818,9 +1051,12 @@ Roofline::RenderMenus(ImVec2 region, ImVec2 plot_pos, ImVec2 plot_size,
                 }
                 case ItemModel::Type::Intensity:
                 {
-                    display =
-                        m_items[i].info.intensity &&
-                        (m_kernel ? m_items[i].parent_info.kernel == m_kernel : true);
+                    // The menu always lists the full data set; in single-kernel
+                    // mode that data set is just the selected kernel.
+                    display = m_items[i].info.intensity &&
+                              (m_kernel_mode == SingleKernel
+                                   ? m_items[i].parent_info.kernel == m_kernel
+                                   : true);
                     break;
                 }
             }
@@ -893,10 +1129,22 @@ Roofline::RenderMenus(ImVec2 region, ImVec2 plot_pos, ImVec2 plot_size,
                 {
                     m_hovered_item_idx = i;
                     item_hovered       = true;
-                    if(row_clicked && m_menus_mode == Options)
+                    if(row_clicked)
                     {
-                        m_items[i].visible = !m_items[i].visible;
-                        m_options_changed  = true;
+                        if(m_menus_mode == Options)
+                        {
+                            m_items[i].visible = !m_items[i].visible;
+                            m_options_changed  = true;
+                        }
+                        else if(m_kernel_mode == AllKernels &&
+                                m_items[i].type == ItemModel::Type::Intensity)
+                        {
+                            ToggleKernelIsolation(m_items[i].parent_info.kernel);
+                        }
+                        else if(m_items[i].type == ItemModel::Type::CeilingBandwidth)
+                        {
+                            ToggleBandwidthIsolation(m_items[i].subtype.bandwidth);
+                        }
                     }
                 }
                 ImGui::PopStyleColor(3);
@@ -1030,33 +1278,71 @@ Roofline::PlotHoverIdx()
 void
 Roofline::ApplyPreset(PresetModel::Type type)
 {
-    // Disable all compute cielings...
-    for(size_t i = 0;
-        i < static_cast<size_t>(__KRPVControllerRooflineCeilingComputeTypeLast); i++)
+    m_active_preset = type;
+    RecomputeVisibility();
+}
+
+void
+Roofline::RecomputeVisibility()
+{
+    for(ItemModel& item : m_items)
     {
-        m_items[i].visible = false;
+        switch(item.type)
+        {
+            case ItemModel::Type::CeilingCompute:
+            {
+                // Enabled below from the active preset.
+                item.visible = false;
+                break;
+            }
+            case ItemModel::Type::CeilingBandwidth:
+            {
+                item.visible = !m_isolated_bandwidth ||
+                               item.subtype.bandwidth == m_isolated_bandwidth.value();
+                break;
+            }
+            case ItemModel::Type::Intensity:
+            {
+                bool level_ok = !m_memory_peak_filter ||
+                                item.subtype.intensity == m_memory_peak_filter.value();
+                bool kernel_ok =
+                    m_kernel_mode == SingleKernel
+                        ? item.parent_info.kernel == m_kernel
+                        : (!m_isolated_kernel ||
+                           item.parent_info.kernel == m_isolated_kernel);
+                item.visible = level_ok && kernel_ok;
+                break;
+            }
+        }
     }
-    // Enable preset's compute ceilings...
-    for(const size_t& item_idx : m_presets[type].item_indices)
+    for(const size_t& item_idx : m_presets[m_active_preset].item_indices)
     {
         m_items[item_idx].visible = true;
     }
-    // Enable all bandwidth ceilings...
-    for(size_t i = static_cast<size_t>(__KRPVControllerRooflineCeilingComputeTypeLast);
-        i < static_cast<size_t>(__KRPVControllerRooflineCeilingComputeTypeLast +
-                                __KRPVControllerRooflineCeilingBandwidthTypeLast);
-        i++)
+    // Visibility can change which ceilings are shown, so recompute the ridges.
+    m_options_changed = true;
+}
+
+void
+Roofline::ToggleKernelIsolation(const KernelInfo* kernel)
+{
+    m_isolated_kernel = (kernel && m_isolated_kernel != kernel) ? kernel : nullptr;
+    RecomputeVisibility();
+}
+
+void
+Roofline::ToggleBandwidthIsolation(
+    rocprofvis_controller_roofline_ceiling_bandwidth_type_t bandwidth)
+{
+    if(m_isolated_bandwidth && m_isolated_bandwidth.value() == bandwidth)
     {
-        m_items[i].visible = true;
+        m_isolated_bandwidth = std::nullopt;
     }
-    // Enable all kernels...
-    for(size_t i = static_cast<size_t>(__KRPVControllerRooflineCeilingComputeTypeLast +
-                                       __KRPVControllerRooflineCeilingBandwidthTypeLast);
-        i < m_items.size(); i++)
+    else
     {
-        m_items[i].visible = true;
+        m_isolated_bandwidth = bandwidth;
     }
-    m_options_changed = true;
+    RecomputeVisibility();
 }
 
 }  // namespace View
diff --git a/src/view/src/compute/rocprofvis_compute_roofline.h b/src/view/src/compute/rocprofvis_compute_roofline.h
index 688dc061e..a72525f8e 100644
--- a/src/view/src/compute/rocprofvis_compute_roofline.h
+++ b/src/view/src/compute/rocprofvis_compute_roofline.h
@@ -96,22 +96,40 @@ class Roofline : public RocWidget
         std::vector<size_t> item_indices;
     };
 
+    // Always-visible horizontal filter toolbar drawn above the plot.
+    void RenderToolbar();
     void RenderMenus(ImVec2 region, ImVec2 plot_pos, ImVec2 plot_size,
                      const ImGuiStyle& style, const ImPlotStyle& plot_style,
                      bool& item_hovered);
     void PlotHoverIdx();
     void ApplyPreset(PresetModel::Type type);
+    // Recompute every item's visibility from the active preset and the
+    // intensity/kernel/bandwidth filters. The chart, legend, and hover read
+    // visibility; the Options menu always lists the full data set.
+    void RecomputeVisibility();
+    void ToggleKernelIsolation(const KernelInfo* kernel);
+    void ToggleBandwidthIsolation(
+        rocprofvis_controller_roofline_ceiling_bandwidth_type_t bandwidth);
 
     // Internal models...
     std::vector<ItemModel>   m_items;
     std::vector<PresetModel> m_presets;
+    // Filter options actually present in the workload (non-empty only).
+    std::vector<rocprofvis_controller_roofline_kernel_intensity_type_t>
+        m_available_intensities;
+    std::vector<rocprofvis_controller_roofline_ceiling_bandwidth_type_t>
+        m_available_bandwidths;
 
     // User options...
-    bool           m_show_menus;
-    MenusMode      m_menus_mode;
-    MenusPlacement m_menus_placement;
-    bool           m_scale_intensity;
-    float          m_line_thickness;
+    bool               m_show_menus;
+    MenusMode          m_menus_mode;
+    MenusPlacement     m_menus_placement;
+    bool               m_scale_intensity;
+    float              m_line_thickness;
+    PresetModel::Type  m_active_preset;
+    // Selected filters. nullopt = show all of that category.
+    std::optional<rocprofvis_controller_roofline_kernel_intensity_type_t>
+        m_memory_peak_filter;
 
     // Internal state...
     bool                  m_workload_changed;
@@ -121,6 +139,9 @@ class Roofline : public RocWidget
     bool                  m_kernel_changed;
     const KernelInfo*     m_kernel;
     uint32_t              m_requested_kernel_id;
+    const KernelInfo*     m_isolated_kernel;
+    std::optional<rocprofvis_controller_roofline_ceiling_bandwidth_type_t>
+        m_isolated_bandwidth;
     bool                  m_options_changed;
     bool                  m_plot_zoom_enabled;
     std::optional<size_t> m_hovered_item_idx;