Johannes Kung
--- a/src/simudator/cli/printing.py 0 → 100644
+++ b/src/simudator/cli/printing.py 0 → 100644
+def pretty_print_verbose(
+    processor: Processor, ignore_keys: list[str] | None = None
+) -> None:
+    """
+    Print the most relevant information about each module in a compact and
+    readable format.
+
+    State variables of modules can be ignored with the optional argument.
+
+    Parameters
+    ----------
+    ignore_keys : list[str]
+        List of names of state variables of modules to exclude when
+        printing module states.
+    """
+    # TODO: ignore keys per module and not for all modules
--- a/src/simudator/cli/printing.py 0 → 100644
+++ b/src/simudator/cli/printing.py 0 → 100644
+    for module in processor.get_modules():
+        if not isinstance(module, Bus):
+            if isinstance(module, Memory) or isinstance(module, MicroMemory):
+                memory_modules.append(module)
+            else:
+                other_modules.append(module)
+
+    # sort the modules by name to ensure that they appear in the
+    # same order
+    memory_modules.sort(key=lambda x: x.name, reverse=True)
+    other_modules.sort(key=lambda x: x.name, reverse=True)
+
+    # specify which keys to ignore from the modules 'get_state'
+    # function
+    # TODO: ignore fields per module, this will ignore 'mask'
+    # for every module
--- a/src/simudator/core/processor.py
+++ b/src/simudator/core/processor.py
-        self.lambdas: dict[str, Callable[..., bool]] = {}
+        self._breakpoint_id_counter: int = 1
+        self._breakpoints: dict[int, Breakpoint] = {}
+        self.breakpoint_reached: bool = False
+        self.last_breakpoint: Breakpoint | None = None
+        self._lambdas: dict[str, Callable[..., bool]] = {}

        # Saving processor state for saving/loading to file and undoing ticks
-        self.removed_cycles = 0
-        self.assembly_cycles = [0]  # Map asm instruction to clock cycle
-        self.module_history: list[dict[str, dict[str, Any]]] = []
-        self.signal_history: list[list] = []  # TODO: Is this needed?
+        self._removed_cycles: int = 0
+        self._assembly_cycles: list[int] = [0]  # Map asm instruction to clock cycle
+        self._module_history: list[dict[str, dict[str, Any]]] = []
+        self._signal_history: list[list] = []  # TODO: Is this needed?
--- a/src/simudator/core/processor.py
+++ b/src/simudator/core/processor.py
        # For showing which instructions are being done and signalling
        # the start of a new one
-        self.new_instruction = False
+        self._new_instruction: bool = False

        # It is the responsibility of the CPU to tell the gui:s pipeline
        # diagram what information to be displayed and how to display it.
        # Thus each CPU keeps track of its current instructions together with
        # each instructions position in the pipeline diagram.
-        self.current_instructions: list[tuple[str, int, int]] = []
+        self._current_instructions: list[tuple[str, int, int]] = []

        # TODO: keeping track of what pieces of info not to show
        # show not be done at the processor level.
        # Maybe implement a 'get_pretty_print_state' at module
        # level?
--- a/src/simudator/core/processor.py
+++ b/src/simudator/core/processor.py
        Also record the breakpoint that was reached.
        """
        self.breakpoint_reached = False
-        for _, bp in self.breakpoints.items():
+        for _, bp in self._breakpoints.items():
            # TODO: Can make this more efficient by only checking enabled
            # breakpoints