@@ -817,6 +817,31 @@ def _map_voltage_history(self, h: dict) -> torch.Tensor:
         h['view'] = view
         return view
 
+    def reset_history(self) -> None:
+        # language=rst
+        """
+        Zero the spike/voltage history GL buffers and the running voltage min/max,
+        so a reset clears every recorded sample (not just the live state). Maps each
+        buffer with CUDA, zeros it in place via the cached torch view, and hands it
+        back to GL. Safe to call between steps (the timer loop is single-threaded, so
+        no step is concurrently holding a map).
+        """
+        for h in self._spike_history.values():
+            view = self._map_history(h)
+            view.zero_()
+            (err,) = driver.cuGraphicsUnmapResources(1, h['res'], 0)
+            if err != 0:
+                raise RuntimeError(f"unmap spike history (reset) failed: {err}")
+        for h in self._voltage_history.values():
+            view = self._map_voltage_history(h)
+            view.zero_()
+            (err,) = driver.cuGraphicsUnmapResources(1, h['res'], 0)
+            if err != 0:
+                raise RuntimeError(f"unmap voltage history (reset) failed: {err}")
+            h['vmin'].fill_(float('inf'))
+            h['vmax'].fill_(float('-inf'))
+        self._step_t = 0
+
     def step(self, input: Dict[str, torch.Tensor], t: int = None) -> None:
         ### Simulate network activity for one time step ###
         if t is None:
 
@@ -2,15 +2,28 @@
 import time
 import torch
 from bindsnet.rendering.widgets import AbstractWidget
+from bindsnet.rendering.controls import QtControlPanel
 from bindsnet.network.network import GUINetwork
 
+# Plots always render on the GLFW backend. GLFW renders straight to the window (bare
+# buffer swap) and drives the sim from a tight poll-loop, so the simulation runs at
+# full speed. vispy's Qt backend instead renders via an offscreen QOpenGLWidget that
+# Qt composites every frame, and dispatches each sim step through a QTimer + the Qt
+# event loop -- both much slower (this is why embedding the canvas in Qt was sluggish
+# even at 1:1 DPI). Controls live outside the render path; see `controls` below.
+app.use_app('glfw')
+
 
 class Application():
   def __init__(self, network: GUINetwork, width=1400, height=900, title="BindsNET GUI",
                header: str | None = None,
-               step_rate: int | str = 500, draw_fps: float | None = None):
+               step_rate: int | str = 500, draw_fps: float | None = None,
+               parameters: dict | None = None):
     self.width, self.height = width, height
     self.network = network
+    # Optional {label: value} map surfaced as editable rows in the control panel's
+    # Parameters section (for future model-rebuild support).
+    self.parameters = parameters
     self.widgets = []
     self.inputs = None      # Set when run() is called; Inputs into network during runtime
     self.runtime = None     # Set when run() is called; Total runtime of network simulation
@@ -25,7 +38,18 @@ def __init__(self, network: GUINetwork, width=1400, height=900, title="BindsNET
     self.draw_fps = draw_fps
     self._last_draw = None
 
-    # Initialize VisPy canvas and grid layout for widget rendering
+    # --- Simulation run-state, driven by whichever control panel is active -----
+    # The timer always ticks; whether a tick advances the sim depends on this state.
+    #   running     : continuous play (Play/Pause)
+    #   step_budget : count of discrete steps queued (Step / Run N), consumed one
+    #                 per tick even while `running` is False.
+    # "active" (advancing) == running or step_budget > 0; otherwise the sim idles
+    # and the plot cameras are handed to the user for zoom/pan.
+    self.running = False
+    self.step_budget = 0
+    self._was_active = None   # last active-state, to fire play<->pause transitions once
+
+    # Initialize VisPy canvas (GLFW) and grid layout for widget rendering.
     self.canvas = scene.SceneCanvas(
       title=title,
       keys='interactive',
@@ -52,6 +76,10 @@ def __init__(self, network: GUINetwork, width=1400, height=900, title="BindsNET
     # Migrate network tensors to shared OpenGL buffers
     network.migrate()
 
+    # Build the control surface (a separate Qt window). It calls back into
+    # toggle_play/step_once/run_n and reads back via set_time etc.
+    self.panel = QtControlPanel(self, parameters=self.parameters)
+
   def add_widget(self, widget: AbstractWidget, row: int, col: int):
     self.widgets.append(widget)
     self.grid.add_widget(widget.grid, row, col)
@@ -61,34 +89,95 @@ def add_widget(self, widget: AbstractWidget, row: int, col: int):
     if self.runtime is not None:
       widget.prime(self.network, self.runtime)
 
+  # --- Control callbacks (panel-agnostic) ------------------------------------
+  def toggle_play(self):
+    self.running = not self.running
+    self.panel.set_playing(self.running)
+
+  def step_once(self):
+    # Queue a single simulation step; consumed on the next tick even while paused.
+    self.step_budget += 1
+
+  def run_n(self, n: int):
+    # Queue N steps.
+    if n and n > 0:
+      self.step_budget += int(n)
+
+  def reset(self):
+    # Clear the network's live state AND its recorded GL history, rewind to t=0,
+    # restore every plot's initial view, and re-arm the run-state machine. The timer
+    # is restarted in case the run had already finished (step() stops it at the end).
+    self.running = False
+    self.step_budget = 0
+    self._was_active = None
+    self._last_draw = None
+    self.current_time = 0
+    self.network.reset_state_variables()
+    self.network.reset_history()
+    for widget in self.widgets:
+      widget.reset()
+    # Re-lock cameras to the running (non-interactive) state via the transition path.
+    self._set_active(False)
+    if hasattr(self, "timer") and not self.timer.running:
+      self.timer.start()
+    self.panel.on_reset()
+    self.canvas.update()
+
+  def _set_active(self, active: bool):
+    # Fire on each play<->pause transition: lock the cameras (and resume the
+    # follow window) while advancing, hand them back for zoom/pan while idle.
+    if active == self._was_active:
+      return
+    for widget in self.widgets:
+      widget.set_paused(not active)
+    self._was_active = active
+
   def step(self, event):
     # Check if runtime is over
     if self.current_time >= self.runtime:
       self.timer.stop()
       # Hand the (bounded) cameras to the user now that the follow window is done.
       for widget in self.widgets:
         widget.finish()
+      self.running = False
+      self.panel.on_finish()
       self.canvas.update()
       return
 
+    # Advance only when playing or there are queued steps; otherwise idle so the
+    # user can zoom/pan the paused plots.
+    active = self.running or self.step_budget > 0
+    self._set_active(active)
+    if not active:
+      return
+
+    t = self.current_time
+
     # Simulate one timestep in network
-    tstep_inputs = {layer_name: layer_inputs[self.current_time] for layer_name, layer_inputs in self.inputs.items()}
-    self.network.step(tstep_inputs, self.current_time)
+    tstep_inputs = {layer_name: layer_inputs[t] for layer_name, layer_inputs in self.inputs.items()}
+    self.network.step(tstep_inputs, t)
 
     # Cheap per-step data capture into GPU buffers -- ALWAYS every step, so the data
     # is complete regardless of how often we draw.
     for widget in self.widgets:
-      widget.capture(self.current_time)
+      widget.capture(t)
+
+    manual = not self.running              # advancing via Step / Run N, not Play
+    if self.step_budget > 0:
+      self.step_budget -= 1
 
     # Throttle the expensive part: widget.render() (camera/axes/uniforms) + the
-    # full-canvas redraw + buffer swap. render() schedules its own redraw, so it is
-    # gated together with canvas.update().
-    if self._should_draw():
+    # full-canvas redraw + buffer swap. Force a draw on the final queued manual step
+    # so a Step / Run N result is shown immediately rather than at the next throttled
+    # draw.
+    force_draw = manual and self.step_budget == 0
+    if force_draw or self._should_draw():
       for widget in self.widgets:
-        widget.render(self.current_time)
+        widget.render(t)
       self.canvas.update()
 
     self.current_time += 1
+    self.panel.set_time(self.current_time, self.runtime)
 
   def _should_draw(self):
     if self.draw_fps is None:
@@ -105,5 +194,12 @@ def run(self, inputs: dict[str, torch.Tensor], runtime: int):
     # Prime widgets now that runtime is known (full-history buffers need it).
     for widget in self.widgets:
       widget.prime(self.network, runtime)
+    # Start paused: the timer ticks, but the sim only advances once the user hits
+    # Play / Step / Run N (the plot cameras are interactive while idle).
     self.timer = app.Timer(interval=self.step_rate, connect=self.step, start=True)
+    # A separate ~60 Hz timer pumps the control panel's event loop when it has one
+    # (the Qt window); the GLFW loop ticks both timers. The plots are unaffected.
+    if self.panel.needs_pump:
+      self.pump_timer = app.Timer(interval=1/60, connect=lambda e: self.panel.pump(), start=True)
     app.run()
+    self.panel.shutdown()
@@ -98,11 +98,23 @@ def render(self, t):
     # on draw steps (see Application.draw_fps throttling).
     pass
 
+  def set_paused(self, paused: bool):
+    # Called by the app on every play<->pause transition. Default: nothing to do.
+    # Override for widgets that lock the camera while running so it can be handed
+    # to the user for zoom/pan while paused (see GraphPlotWidget).
+    pass
+
   def finish(self):
     # Called once when the simulation completes. Default: nothing to do. Override
     # for widgets that lock interaction during the run (graph plots).
     pass
 
+  def reset(self):
+    # Called by the app when the simulation is reset (network state cleared, time
+    # back to 0). Default: nothing to do. Override to restore the initial camera
+    # view; the underlying GL history buffers are cleared by GUINetwork.reset_history.
+    pass
+
 
 # A plotting widget with x and y axis
 class GraphPlotWidget(AbstractWidget):
@@ -125,6 +137,22 @@ def __init__(self, link_x=True, link_y=True):
     if link_x: self.x_axis.link_view(self.view)   # follows camera
     if link_y: self.y_axis.link_view(self.view)
 
+    self._initial_rect = None   # starting follow window, captured in each prime()
+
+  def reset(self):
+    # Restore the starting follow window and re-lock the camera; the sim advances
+    # again from t=0 on the next Play/Step (set_paused re-locks too, but reset may
+    # happen after finish() unlocked it).
+    if self._initial_rect is not None:
+      self.view.camera.rect = self._initial_rect
+    self.view.camera.interactive = False
+
+  def set_paused(self, paused: bool):
+    # While paused, hand the (bounded) camera to the user for zoom/pan; while
+    # running, lock it so render()'s per-draw follow window isn't fought by user
+    # input. limit_rect still keeps zoom/pan inside the plotted data.
+    self.view.camera.interactive = paused
+
   def finish(self):
     # Sim done: hand the camera to the user (still bounded by limit_rect).
     self.view.camera.interactive = True
@@ -192,7 +220,8 @@ def prime(self, network, runtime=None):
     self.view.camera.limit_rect = Rect(0, y0, self.total_timesteps, y1 - y0)
     # Start showing the first trailing window; absolute-time x means zoom-out
     # reveals all of history. y grows later as extremes appear (see render).
-    self.view.camera.rect = (0, y0, self.max_timesteps, y1 - y0)
+    self._initial_rect = (0, y0, self.max_timesteps, y1 - y0)
+    self.view.camera.rect = self._initial_rect
     self.y_axis.axis.axis_label = "Voltage (mV)"
     self.x_axis.axis.axis_label = "Timestep"
     # Ticks at constant multiples of `step` so a sliding domain produces smoothly
@@ -272,7 +301,8 @@ def prime(self, network, runtime=None):
     self.view.camera.limit_rect = Rect(0, 0, self.total_timesteps, self.layer_size)
     # Start showing the first trailing window; absolute-time x means zoom-out
     # reveals all of history.
-    self.view.camera.rect = (0, 0, self.max_timesteps, self.layer_size)
+    self._initial_rect = (0, 0, self.max_timesteps, self.layer_size)
+    self.view.camera.rect = self._initial_rect
     self.y_axis.axis.axis_label = "Neuron"
     self.x_axis.axis.axis_label = "Timestep"
     # Ticks at constant multiples of `step` so a sliding domain produces smoothly
@@ -351,7 +381,8 @@ def prime(self, network, runtime=None):
     self.view.add(self.visual)
     # Bound zoom/pan to the matrix extent (target x source neurons).
     self.view.camera.limit_rect = Rect(0, 0, cols, rows)
-    self.view.camera.rect = (0, 0, cols, rows)
+    self._initial_rect = (0, 0, cols, rows)
+    self.view.camera.rect = self._initial_rect
     # Unlike the time-series plots, the heatmap has no follow window fighting the
     # user, so allow free (bounded) zoom/pan for the whole run.
     self.view.camera.interactive = True
@@ -370,6 +401,18 @@ def _add_colorbar(self, clim):
     )
     self.grid.add_widget(self.colorbar, row=0, col=2).width_max = 95
 
+  def set_paused(self, paused: bool):
+    # The heatmap has no follow window fighting the user, so its camera is left
+    # interactive for the whole run (see prime); pausing changes nothing here.
+    pass
+
+  def reset(self):
+    # The heatmap camera stays interactive the whole run (no follow window); just
+    # restore the initial full-matrix view and re-show the (now-cleared) values.
+    if self._initial_rect is not None:
+      self.view.camera.rect = self._initial_rect
+    self.visual.migrate()
+
   def render(self, t):
     if t % self.refresh_every == 0:
       self.visual.migrate()
 
@@ -6,7 +6,7 @@
 SIM_TIME = 1000
 BATCH_SIZE = 1
 DEVICE = "cuda"
-DRAW_FPS = 50          # cap plot redraws; the sim runs as fast as it can between draws
+DRAW_FPS = 30          # cap plot redraws; the sim runs as fast as it can between draws
 
 IN_SIZE = 100
 EXC_SIZE = 20_000
@@ -26,8 +26,17 @@
   INH_TO_EXC_CONNECTIVITY,
   EXC_TO_INH_CONNECTIVITY,
 )
-app = Application(network, 1400, 900, header="BindsNET Network Activity",
-                  step_rate=99999999999, draw_fps=DRAW_FPS)
+app = Application(network, 2800, 1800, header="BindsNET Network Activity",
+                  step_rate=99999999999, draw_fps=DRAW_FPS,
+                  parameters={
+                    "Input size": IN_SIZE,
+                    "Excitatory size": EXC_SIZE,
+                    "Inhibitory size": INH_SIZE,
+                    "I -> EXC connectivity": I_TO_EXC_CONNECTIVITY,
+                    "I -> INH connectivity": I_TO_INH_CONNECTIVITY,
+                    "INH -> EXC connectivity": INH_TO_EXC_CONNECTIVITY,
+                    "EXC -> INH connectivity": EXC_TO_INH_CONNECTIVITY,
+                  })
 inputs = {"I": torch.rand(SIM_TIME, BATCH_SIZE, IN_SIZE, device=DEVICE) > 0.90}
 app.add_widget(
   RasterPlot(layer_name="EXC_LIF", max_timesteps=500),