Ghidrust provides a hyper fast, AI native reverse engineering platform built in Rust, inspired by Ghidra. Includes experimental GPU kernels to rapidly decompile large files, a decryption suite, and network monitor for packet to binary reverse engineering.
//! Shell dialogs — configure/layouts/goto/search/analysis/GPU.
//!
//! Extracted per demonolith Wave 7. Nested under `app` for private field access.
use super::{ConfigureSection, GhidrustApp};
use crate::layout_tokens::{FieldWidth, WinTier};
use crate::listing::ui_options_dialog;
use crate::menu_actions::{parse_address, processor_info};
use crate::panes::BookmarkKind;
use eframe::egui::{self, Color32};
use ghidrust_core::{analyzer_supports_gpu, AppearanceTheme, ThemeMode, ThemeDensity};
impl GhidrustApp {
/// Draw configure/layouts/goto/search/analysis/GPU dialogs.
pub(crate) fn draw_shell_dialogs(&mut self, ctx: &egui::Context) {
let d = self.theme_spec().density;
if self.show_search_address_tables_dialog {
let mut open = true;
egui::Window::new("Address Tables")
.open(&mut open)
.show(ctx, |ui| {
ui.label(format!("{} recovered table(s)", self.text_hits.len()));
for hit in &self.text_hits {
ui.monospace(format!("{} {}", hit.va.map(|v| format!("{v:#x}")).unwrap_or_default(), hit.text));
}
if ui.button("Show results").clicked() {
self.show_search_results = true;
}
});
self.show_search_address_tables_dialog = open;
}
if self.show_prefs_dialog {
let mut open = true;
egui::Window::new("Preferences")
.open(&mut open)
.show(ctx, |ui| {
ui.label(format!("Appearance: {}", self.appearance.display_name()));
ui.label(format!("Theme mode: {:?}", self.theme));
ui.separator();
ui.strong("Known hotkeys");
ui.monospace("F5 Continue · F7 Step Into · F8 Step Over · Shift+F8 Step Out");
ui.monospace("Ctrl+Down Next Function · Ctrl+Up Previous Function · F1 Help");
});
self.show_prefs_dialog = open;
}
if self.show_help_dialog {
let mut open = true;
egui::Window::new("Ghidrust Help")
.open(&mut open)
.resizable(true)
.show(ctx, |ui| {
ui.heading(format!("Ghidrust {}", env!("CARGO_PKG_VERSION")));
ui.label("Use File to load/import binaries, Analysis to run analyzers, and Window to open providers.");
ui.separator();
ui.strong("Built-in scripts");
for script in crate::scripts::builtin_catalog() {
ui.monospace(script.name);
}
});
self.show_help_dialog = open;
}
if self.show_tools_dialog {
let mut open = true;
egui::Window::new(&self.tools_dialog_title)
.open(&mut open)
.resizable(true)
.show(ctx, |ui| { ui.monospace(&self.tools_dialog_body); });
self.show_tools_dialog = open;
}
// Configure dialog (Appearance + Plugins).
if self.show_configure_dialog {
let mut close = false;
let mut appearance_changed = false;
let mut next_appearance = self.appearance;
let mut next_mode = self.theme;
let mut next_section = self.configure_section;
egui::Window::new("Configure")
.id(egui::Id::new("dialog_configure"))
.resizable(true)
.default_size(WinTier::Lg.size(&d))
.show(ctx, |ui| {
ui.horizontal(|ui| {
ui.vertical(|ui| {
ui.set_min_width(d.panel_symbol_min);
ui.strong("Configure");
ui.add_space(d.space_sm);
if ui
.selectable_label(
next_section == ConfigureSection::Appearance,
"Appearance",
)
.clicked()
{
next_section = ConfigureSection::Appearance;
}
if ui
.selectable_label(
next_section == ConfigureSection::Plugins,
"Plugins",
)
.clicked()
{
next_section = ConfigureSection::Plugins;
}
});
ui.separator();
ui.vertical(|ui| {
match next_section {
ConfigureSection::Appearance => {
ui.heading("Appearance");
ui.label(
"Select a theme family. Classic Ghidrust is the historical default.",
);
ui.add_space(d.space_md);
for theme in AppearanceTheme::ALL {
let selected = next_appearance == *theme;
if ui
.selectable_label(selected, theme.display_name())
.on_hover_text(theme.description())
.clicked()
{
next_appearance = *theme;
appearance_changed = true;
}
if selected {
ui.indent(theme.id(), |ui| {
ui.small(theme.description());
});
}
}
ui.add_space(d.space_lg);
ui.separator();
ui.horizontal(|ui| {
let mode_caption = match next_appearance {
AppearanceTheme::FutureConsole => "Gas",
_ => "Mode",
};
ui.label(format!("{mode_caption}:"));
let dark_label = match next_appearance {
AppearanceTheme::FutureConsole => "Neon",
_ => "Dark",
};
let light_label = match next_appearance {
AppearanceTheme::FutureConsole => "Amber",
_ => "Light",
};
if ui
.selectable_label(
next_mode == ThemeMode::Dark,
dark_label,
)
.clicked()
{
next_mode = ThemeMode::Dark;
appearance_changed = true;
}
if ui
.selectable_label(
next_mode == ThemeMode::Light,
light_label,
)
.clicked()
{
next_mode = ThemeMode::Light;
appearance_changed = true;
}
});
if next_appearance == AppearanceTheme::FutureConsole {
ui.small(
"Future Console tokens transcribed 1:1 from Amber Console (BSD-3-Clause).",
);
}
}
ConfigureSection::Plugins => {
ui.heading("Plugins");
ui.label(
"Ghidrust plugins are compile-time; this lists every provider shipped.",
);
ui.separator();
egui::ScrollArea::vertical()
.id_salt("configure_scroll")
.max_height(d.scroll_md)
.show(ui, |ui| {
egui::Grid::new("configure_grid")
.num_columns(4)
.striped(true)
.show(ui, |ui| {
ui.strong("Plugin");
ui.strong("Kind");
ui.strong("State");
ui.strong("Description");
ui.end_row();
for p in crate::layouts::PLUGIN_CATALOG {
ui.monospace(p.name);
ui.label(p.kind);
ui.label(p.state);
ui.label(p.description);
ui.end_row();
}
});
});
}
}
});
});
ui.separator();
if ui.button("Close").clicked() {
close = true;
}
});
self.configure_section = next_section;
if appearance_changed {
self.appearance = next_appearance;
self.theme = next_mode;
self.apply_theme(ctx);
self.log(format!(
"Appearance → {} ({})",
self.appearance.display_name(),
self.appearance.mode_label(self.theme)
));
}
if close {
self.show_configure_dialog = false;
}
}
// Layout save / load dialog.
if self.show_layouts_dialog {
let mut close = false;
let mut do_save = false;
let mut load_name: Option<String> = None;
let mut delete_name: Option<String> = None;
egui::Window::new("Tool Layouts")
.id(egui::Id::new("dialog_layouts"))
.resizable(true)
.default_size(WinTier::Md.size(&d))
.show(ctx, |ui| {
ui.label("Save / restore CodeBrowser tool layouts (pane visibility + docks).");
ui.small(
egui::RichText::new(
"Files land under %APPDATA%/ghidrust/layouts/<name>.tool.json .",
)
.weak(),
);
ui.separator();
ui.horizontal(|ui| {
ui.label("Name:");
ui.add(
egui::TextEdit::singleline(&mut self.layouts_new_name)
.desired_width(FieldWidth::Std.px(&ThemeDensity::FIB_DESKTOP))
.hint_text("MyCodeBrowser"),
);
if ui
.add_enabled(
!self.layouts_new_name.trim().is_empty(),
egui::Button::new("Save current layout"),
)
.clicked()
{
do_save = true;
}
});
ui.separator();
ui.label(egui::RichText::new("Saved layouts").strong());
if self.layouts_cached.is_empty() {
ui.weak("No layouts saved yet.");
} else {
egui::ScrollArea::vertical()
.id_salt("layouts_scroll")
.max_height(d.scroll_sm)
.show(ui, |ui| {
for name in &self.layouts_cached {
ui.horizontal(|ui| {
ui.monospace(name);
if ui.small_button("Restore").clicked() {
load_name = Some(name.clone());
}
if ui.small_button("Delete").clicked() {
delete_name = Some(name.clone());
}
});
}
});
}
ui.separator();
if !self.current_layout_name.is_empty() {
ui.small(
egui::RichText::new(format!(
"Current layout: {}",
self.current_layout_name
))
.weak(),
);
}
if ui.button("Close").clicked() {
close = true;
}
});
if do_save {
match self.save_layout_named(self.layouts_new_name.clone()) {
Ok(p) => {
self.status = format!("Layout saved → {}", p.display());
self.log(self.status.clone());
}
Err(e) => {
self.status = format!("save layout error: {e}");
self.log_error(self.status.clone());
}
}
}
if let Some(name) = load_name {
match self.restore_layout_named(&name) {
Ok(()) => {
self.apply_theme(ctx);
self.status = format!("Layout restored → {name}");
self.log(self.status.clone());
}
Err(e) => {
self.status = format!("restore layout error: {e}");
self.log_error(self.status.clone());
}
}
}
if let Some(name) = delete_name {
if let Err(e) = crate::layouts::delete_layout(&name) {
self.status = format!("delete layout error: {e}");
self.log_error(self.status.clone());
}
self.layouts_cached = crate::layouts::list_layouts();
}
if close {
self.show_layouts_dialog = false;
}
}
// Bookmark add dialog
if self.show_bookmark_dialog {
let mut close = false;
let mut confirmed = false;
egui::Window::new("Add Bookmark")
.id(egui::Id::new("dialog_add_bookmark"))
.collapsible(false)
.resizable(false)
.anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
.show(ctx, |ui| {
ui.label("Kind:");
egui::ComboBox::from_id_salt("bookmark_kind")
.selected_text(self.bookmark_dialog_kind.label())
.show_ui(ui, |ui| {
for k in BookmarkKind::ALL {
ui.selectable_value(&mut self.bookmark_dialog_kind, *k, k.label());
}
});
ui.label("Category:");
ui.text_edit_singleline(&mut self.bookmark_dialog_category);
ui.label("Description:");
ui.text_edit_singleline(&mut self.bookmark_dialog_description);
ui.horizontal(|ui| {
if ui.button("Cancel").clicked() {
close = true;
}
if ui.button("Add").clicked() {
confirmed = true;
close = true;
}
});
});
if confirmed {
if let Some(va) = self.listing_focus_va {
let kind = self.bookmark_dialog_kind;
let cat = self.bookmark_dialog_category.clone();
let desc = self.bookmark_dialog_description.clone();
self.add_bookmark(va, kind, cat, desc);
}
}
if close {
self.show_bookmark_dialog = false;
}
}
// Navigation → Go To Address
if self.show_goto_dialog {
egui::Window::new("Go To Address")
.collapsible(false)
.resizable(false)
.anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
.show(ctx, |ui| {
ui.label("Address (hex, optional 0x prefix):");
ui.text_edit_singleline(&mut self.goto_input);
ui.horizontal(|ui| {
if ui.button("Cancel").clicked() {
self.show_goto_dialog = false;
}
if ui.button("Go").clicked() {
match self.goto_address_str(&self.goto_input.clone()) {
Ok(()) => self.show_goto_dialog = false,
Err(e) => {
self.status = format!("error: {e}");
self.log(self.status.clone());
}
}
}
});
});
}
// Search → Memory
if self.show_search_memory_dialog {
egui::Window::new("Search Memory")
.collapsible(false)
.resizable(true)
.default_width(WinTier::Sm.width(&d))
.anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
.show(ctx, |ui| {
ui.label("Byte pattern (hex; ?? = wildcard):");
ui.text_edit_singleline(&mut self.search_memory_input);
ui.small("Example: 55 48 89 e5 or 48??e5");
ui.horizontal(|ui| {
if ui.button("Cancel").clicked() {
self.show_search_memory_dialog = false;
}
if ui.button("Search").clicked() {
match self.run_search_memory() {
Ok(()) => self.show_search_memory_dialog = false,
Err(e) => {
self.status = format!("error: {e}");
self.log(self.status.clone());
}
}
}
});
});
}
// Search → Program Text
if self.show_search_text_dialog {
egui::Window::new("Search Program Text")
.collapsible(false)
.resizable(true)
.default_width(WinTier::Sm.width(&d))
.anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
.show(ctx, |ui| {
ui.label("Query (listing / symbols / functions / memory text):");
ui.text_edit_singleline(&mut self.search_text_input);
ui.checkbox(&mut self.search_text_case_insensitive, "Case insensitive");
ui.horizontal(|ui| {
if ui.button("Cancel").clicked() {
self.show_search_text_dialog = false;
}
if ui.button("Search").clicked() {
match self.run_search_text() {
Ok(()) => self.show_search_text_dialog = false,
Err(e) => {
self.status = format!("error: {e}");
self.log(self.status.clone());
}
}
}
});
});
}
// Search → For Scalars
if self.show_search_scalars_dialog {
egui::Window::new("Search For Scalars")
.collapsible(false)
.resizable(false)
.anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
.show(ctx, |ui| {
ui.label("Scan operand scalars in [min, max]. Hex ok (0x…) or decimal.");
ui.horizontal(|ui| {
ui.label("Min:");
ui.text_edit_singleline(&mut self.search_scalars_min);
});
ui.horizontal(|ui| {
ui.label("Max:");
ui.text_edit_singleline(&mut self.search_scalars_max);
});
ui.horizontal(|ui| {
if ui.button("Cancel").clicked() {
self.show_search_scalars_dialog = false;
}
if ui.button("Search").clicked() {
match self.run_search_scalars() {
Ok(()) => self.show_search_scalars_dialog = false,
Err(e) => {
self.status = format!("error: {e}");
self.log_error(self.status.clone());
}
}
}
});
});
}
// Search → Instruction Patterns
if self.show_search_insn_dialog {
egui::Window::new("Search Instruction Patterns")
.collapsible(false)
.resizable(true)
.default_width(WinTier::Sm.width(&d))
.anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
.show(ctx, |ui| {
ui.small("Matches against decoded listing rows. Empty field = don't filter.");
ui.horizontal(|ui| {
ui.label("Mnemonic:");
ui.text_edit_singleline(&mut self.search_insn_mnemonic);
});
ui.horizontal(|ui| {
ui.label("Operands:");
ui.text_edit_singleline(&mut self.search_insn_operands);
});
ui.horizontal(|ui| {
if ui.button("Cancel").clicked() {
self.show_search_insn_dialog = false;
}
if ui.button("Search").clicked() {
match self.run_search_instruction_patterns() {
Ok(()) => self.show_search_insn_dialog = false,
Err(e) => {
self.status = format!("error: {e}");
self.log_error(self.status.clone());
}
}
}
});
});
}
// Add Equate dialog .
if self.show_equate_dialog {
let mut close = false;
egui::Window::new("Set Equate")
.collapsible(false)
.resizable(false)
.anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
.show(ctx, |ui| {
ui.small("Bind a name to a scalar operand .");
ui.horizontal(|ui| {
ui.label("VA:");
let mut input = self
.equate_dialog_va
.map(|v| format!("{v:#x}"))
.unwrap_or_default();
if ui.text_edit_singleline(&mut input).lost_focus() {
self.equate_dialog_va = parse_address(&input).ok();
}
});
ui.horizontal(|ui| {
ui.label("Operand index:");
let mut s = format!("{}", self.equate_dialog_op);
if ui.text_edit_singleline(&mut s).lost_focus() {
self.equate_dialog_op =
s.trim().parse().unwrap_or(self.equate_dialog_op);
}
});
ui.horizontal(|ui| {
ui.label("Name:");
ui.text_edit_singleline(&mut self.equate_dialog_name);
});
ui.horizontal(|ui| {
ui.label("Value (dec / hex):");
ui.text_edit_singleline(&mut self.equate_dialog_value);
});
ui.horizontal(|ui| {
if ui.button("Cancel").clicked() {
close = true;
}
if ui.button("Apply").clicked() {
let value = self
.parse_scalar_input(&self.equate_dialog_value.clone())
.unwrap_or(0);
if let Some(va) = self.equate_dialog_va {
if let Err(e) = self.set_equate(
va,
self.equate_dialog_op,
self.equate_dialog_name.clone(),
value,
) {
self.status = format!("error: {e}");
self.log_error(self.status.clone());
} else {
close = true;
}
} else {
close = true;
}
}
});
});
if close {
self.show_equate_dialog = false;
}
}
// Search results window
if self.show_search_results {
egui::Window::new("Search Results")
.collapsible(true)
.resizable(true)
.default_width(WinTier::Md.width(&d))
.default_height(280.0)
.show(ctx, |ui| {
if ui.button("Close").clicked() {
self.show_search_results = false;
}
ui.separator();
egui::ScrollArea::vertical().show(ui, |ui| {
for h in self.memory_hits.clone() {
if ui
.button(format!(
"{:#x} {} +{:#x}",
h.va, h.block, h.offset_in_block
))
.clicked()
{
let _ = self.goto_address_str(&format!("{:#x}", h.va));
}
}
for h in self.text_hits.clone() {
let label = match h.va {
Some(va) => format!("[{}] {:#x}: {}", h.kind, va, h.text),
None => format!("[{}] {}", h.kind, h.text),
};
if ui.button(label).clicked() {
if let Some(va) = h.va {
let _ = self.goto_address_str(&format!("{va:#x}"));
}
}
}
if self.memory_hits.is_empty() && self.text_hits.is_empty() {
ui.weak("No hits.");
}
});
});
}
// Listing → Decode options
if ui_options_dialog(
ctx,
&mut self.show_decode_options_dialog,
&mut self.decode_opts,
self.program.as_ref(),
) {
self.apply_decode_opts();
}
// Tools → Processor options
if self.show_processor_dialog {
egui::Window::new("Processor Options")
.collapsible(false)
.resizable(true)
.default_width(WinTier::Sm.width(&d))
.anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
.show(ctx, |ui| {
if let Some(prog) = &self.program {
let info = processor_info(prog);
ui.monospace(format!("Language: {}", info.language));
ui.monospace(format!("Compiler: {}", info.compiler));
ui.monospace(format!("Format: {}", info.format));
ui.monospace(format!("Endian: {}", info.endian));
ui.monospace(format!("Pointer size: {} bytes", info.pointer_size));
ui.monospace(format!("Image base: {:#x}", info.image_base));
ui.monospace(format!(
"Entry: {}",
info.entry
.map(|e| format!("{e:#x}"))
.unwrap_or_else(|| "—".into())
));
ui.separator();
ui.small(&info.notes);
ui.separator();
ui.label("Sections:");
egui::ScrollArea::vertical()
.max_height(d.panel_symbol_min)
.show(ui, |ui| {
for s in &prog.sections {
ui.monospace(format!(
"{} va={:#x} vsize={:#x}",
s.name, s.va, s.virtual_size
));
}
});
} else {
ui.weak("Load a program to view processor / language options.");
}
if ui.button("Close").clicked() {
self.show_processor_dialog = false;
}
});
}
// Analysis → GPU Decompile…
if self.show_gpu_decompile_dialog {
let t = self.tokens();
let muted = Color32::from_rgb(
t.on_surface_variant[0],
t.on_surface_variant[1],
t.on_surface_variant[2],
);
let mut close = false;
let mut run_clicked = false;
let has_program = self.program.is_some();
egui::Window::new("GPU Decompile")
.collapsible(false)
.resizable(true)
.default_width(WinTier::Md.width(&d))
.anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
.show(ctx, |ui| {
crate::tool_panes::ui_gpu_decompile_dialog_header(
ui,
&mut self.tool_panes.gpu_decompile,
muted,
);
if !has_program {
ui.weak("No program loaded.");
} else if ui.button("Resolve + Decompile").clicked() {
run_clicked = true;
}
crate::tool_panes::ui_gpu_decompile_dialog_result(
ui,
&self.tool_panes.gpu_decompile,
muted,
);
ui.separator();
if ui.button("Close").clicked() {
close = true;
}
});
if run_clicked {
self.run_gpu_decompile_dialog();
}
if close {
self.show_gpu_decompile_dialog = false;
}
}
if self.show_analysis_dialog && self.analysis_job.is_none() {
let t = self.tokens();
let primary = Color32::from_rgb(t.primary[0], t.primary[1], t.primary[2]);
egui::Window::new("Analysis options")
.collapsible(false)
.resizable(true)
.default_width(WinTier::Md.width(&d))
.anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
.show(ctx, |ui| {
if let Some(ref id) = self.pending_analyze_file_id {
let name = self
.project
.as_ref()
.and_then(|p| p.meta.files.iter().find(|f| f.id == *id))
.map(|f| f.display_name.as_str())
.unwrap_or(id.as_str());
ui.label(
egui::RichText::new(format!("Target: {name}"))
.strong()
.color(primary),
);
ui.add_space(d.space_xs);
}
ui.label("Select analyzers (labels):");
ui.horizontal(|ui| {
if ui.small_button("Select defaults").clicked() {
for (i, info) in self.analyzer_infos.iter().enumerate() {
self.analyzer_enabled[i] = info.default_enabled;
}
}
if ui.small_button("Select all").clicked() {
for e in &mut self.analyzer_enabled {
*e = true;
}
}
if ui.small_button("Clear all").clicked() {
for e in &mut self.analyzer_enabled {
*e = false;
}
}
});
egui::ScrollArea::vertical()
.max_height(d.scroll_md)
.show(ui, |ui| {
for (i, info) in self.analyzer_infos.iter().enumerate() {
ui.horizontal(|ui| {
ui.checkbox(&mut self.analyzer_enabled[i], &info.name);
match info.status {
ghidrust_core::AnalyzerStatus::Implemented => {
ui.weak("ready");
}
ghidrust_core::AnalyzerStatus::NotImplemented => {
ui.weak("stub");
}
}
// Per-row GPU indicator (master checkbox gates actual use).
let supports = analyzer_supports_gpu(&info.name);
if supports && self.use_gpu_experimental {
ui.label(
egui::RichText::new("GPU")
.small()
.strong()
.color(primary),
)
.on_hover_text(
"Master GPU is on — this analyzer will use its GPU \
strategy (bulk and/or seed enrich). Falls back to CPU \
on failure.",
);
} else if supports {
ui.label(
egui::RichText::new("GPU")
.small()
.color(Color32::from_rgb(120, 120, 128)),
)
.on_hover_text(
"GPU strategy available — enable the master GPU checkbox \
to use it. Currently CPU.",
);
} else {
ui.label(
egui::RichText::new("CPU only")
.small()
.color(Color32::from_rgb(120, 120, 128)),
)
.on_hover_text(
"No GPU strategy for this analyzer — always runs on CPU.",
);
}
});
}
});
ui.separator();
ui.checkbox(
&mut self.use_gpu_experimental,
"GPU (only analyzers with a GPU strategy)",
);
ui.small(
"wgpu when available: GPU bulk / SIMT seed enrich only for analyzers \
marked GPU above (see strategy matrix). Others stay CPU-only. \
Large images are multi-dispatch chunked (≤65535 workgroups). \
Falls back to CPU on failure. GPU decompile is a separate tool.",
);
ui.add_space(d.space_md);
ui.horizontal(|ui| {
let can_run = self.analyzer_enabled.iter().any(|e| *e)
&& (self.program.is_some() || self.pending_analyze_file_id.is_some());
if ui
.add_enabled(can_run, egui::Button::new("Run Analysis"))
.clicked()
{
match self.begin_analysis_job() {
Ok(()) => {
self.show_analysis_dialog = false;
}
Err(e) => {
self.status = format!("error: {e}");
self.log(self.status.clone());
}
}
}
if ui.button("Cancel").clicked() {
self.pending_analyze_file_id = None;
self.show_analysis_dialog = false;
}
});
});
}
}
}