diff --git a/aperoll/proseco_data.py b/aperoll/proseco_data.py
index feef429..d321978 100644
--- a/aperoll/proseco_data.py
+++ b/aperoll/proseco_data.py
@@ -147,7 +147,9 @@ def run_proseco(self):
                     "review_table": aca_review,
                 }
             except Exception as exc:
-                logger.debug(f"ProsecoData failed calling proseco ({type(exc).__name__}): {exc}")
+                logger.debug(
+                    f"ProsecoData failed calling proseco ({type(exc).__name__}): {exc}"
+                )
                 trace = traceback.extract_tb(exc.__traceback__)
                 for step in trace:
                     logger.debug(f"    in {step.filename}:{step.lineno}/{step.name}:")
@@ -167,14 +169,15 @@ def run_sparkles(self):
                 )
                 return self._dir / "sparkles"
             except Exception as exc:
-                logger.debug(f"ProsecoData failed calling sparkles ({type(exc).__name__}): {exc}")
+                logger.debug(
+                    f"ProsecoData failed calling sparkles ({type(exc).__name__}): {exc}"
+                )
                 trace = traceback.extract_tb(exc.__traceback__)
                 for step in trace:
                     logger.debug(f"    in {step.filename}:{step.lineno}/{step.name}:")
                     logger.debug(f"        {step.line}")
                 raise Exception(f"ProsecoData failed calling sparkles: {exc}") from None
 
-
     def open_export_proseco_dialog(self):
         """
         Save the star catalog in a pickle file.
diff --git a/aperoll/widgets/attitude_widget.py b/aperoll/widgets/attitude_widget.py
index e730409..0f0e067 100644
--- a/aperoll/widgets/attitude_widget.py
+++ b/aperoll/widgets/attitude_widget.py
@@ -331,10 +331,7 @@ def _set_attitude(self, attitude, emit=True):
             if emit:
                 self.attitude_cleared.emit()
             return
-        if (
-            not isinstance(attitude, Quat)
-            and len(attitude) == 4
-        ):
+        if not isinstance(attitude, Quat) and len(attitude) == 4:
             attitude = normalize(attitude)
         # this check is to break infinite recursion because in the connections
         q1 = None if attitude is None else Quat(attitude).q
diff --git a/aperoll/widgets/catalog_widget.py b/aperoll/widgets/catalog_widget.py
new file mode 100644
index 0000000..3fa95b3
--- /dev/null
+++ b/aperoll/widgets/catalog_widget.py
@@ -0,0 +1,242 @@
+import numpy as np
+from astropy.table import Table
+from chandra_aca.attitude import calc_att
+from cxotime import CxoTime
+from PyQt5 import QtCore as QtC
+from PyQt5 import QtWidgets as QtW
+from Quaternion import Quat
+
+from aperoll.utils import log_exception, logger
+from aperoll.widgets.attitude_widget import (
+    AttitudeWidget,
+    QuatRepresentation,
+    hstack,
+    vstack,
+)
+from aperoll.widgets.centroid_table import CentroidTable
+from aperoll.widgets.line_edit import LineEdit
+
+
+class CatalogWidget(QtW.QWidget):
+    slot_enabled = QtC.pyqtSignal(int, bool)
+    track = QtC.pyqtSignal(bool)
+    attitude_updated = QtC.pyqtSignal(Quat)
+
+    def __init__(self):
+        super().__init__()
+
+        self.date_edit = LineEdit(self)
+        self.date_edit.setReadOnly(True)
+        self.attitude_widget = AttitudeWidget(
+            self,
+            columns={
+                QuatRepresentation.EQUATORIAL: 0,
+                QuatRepresentation.QUATERNION: 0,
+                QuatRepresentation.SUN: 0,
+            },
+        )
+        self.attitude_widget.set_read_only(True)
+        self.catalog_widget = CentroidTable(
+            columns=["slot", "id", "fid", "yang", "zang", "mag", "enabled"]
+        )
+        self.catalog_widget.set_read_only(True)
+        self.catalog_widget.setMinimumWidth(500)
+        self.catalog_widget.setHorizontalScrollBarPolicy(QtC.Qt.ScrollBarAlwaysOff)
+
+        self.track_button = QtW.QPushButton("Start tracking")
+        self.track_button.setCheckable(True)
+        self.track_button.clicked.connect(self._track)
+
+        date_box = QtW.QGroupBox("Date")
+        date_box.setLayout(
+            vstack(
+                self.date_edit,
+            )
+        )
+
+        self.starcat_source_edit = QtW.QComboBox(self)
+        self.starcat_source_edit.addItems(["Kadi", "Proseco", "Find Attitude"])
+
+        self.centroid_table = CentroidTable(add_enable=False)
+        self.centroid_table.setHorizontalScrollBarPolicy(QtC.Qt.ScrollBarAlwaysOff)
+        self.centroid_table.setMinimumWidth(100)
+
+        source_box = QtW.QGroupBox("Source")
+        source_box.setLayout(
+            vstack(
+                self.starcat_source_edit,
+            )
+        )
+
+        att_box = QtW.QGroupBox("Attitude")
+        att_box.setLayout(
+            vstack(
+                self.attitude_widget,
+            )
+        )
+
+        table_box = QtW.QGroupBox("Catalog")
+        table_box.setLayout(
+            vstack(
+                self.catalog_widget,
+            )
+        )
+
+        centroid_box = QtW.QGroupBox("Centroids")
+        centroid_box.setLayout(
+            vstack(
+                self.centroid_table,
+            )
+        )
+
+        layout = QtW.QHBoxLayout()
+        layout.addStretch()
+        layout.addLayout(
+            vstack(
+                hstack(date_box, source_box),
+                att_box,
+                table_box,
+                centroid_box,
+                hstack(self.track_button, stretch=True),
+                stretch=True,
+            )
+        )
+        layout.addStretch()
+        self.setLayout(layout)
+        self.reset()
+
+        self.tracking = False
+
+        self.catalog_widget.slot_enabled.connect(self.slot_enabled)
+
+    def _track(self, checked):
+        text = "Stop" if checked else "Start"
+        self.track_button.setText(f"{text} tracking")
+
+    def get_tracking(self):
+        return self.track_button.isChecked()
+
+    def set_tracking(self, tracking):
+        self._track(tracking)
+        self.track_button.setChecked(tracking)
+
+    tracking = property(get_tracking, set_tracking)
+
+    def set_attitude(self, attitude):
+        self.attitude_widget.set_attitude(attitude)
+
+    def get_attitude(self):
+        return self.attitude_widget.get_attitude()
+
+    attitude = property(get_attitude, set_attitude)
+
+    def set_date(self, date):
+        date = CxoTime(date).date if date is not None else ""
+        if date != self.date_edit.text():
+            self.date_edit.setText(date)
+
+    def get_date(self):
+        text = self.date_edit.text()
+        if text:
+            return CxoTime(self.date_edit.text())
+
+    date = property(get_date, set_date)
+
+    def get_starcat_source(self):
+        return self.starcat_source_edit.currentText()
+
+    def set_starcat_source(self, source):
+        self.starcat_source_edit.setCurrentText(source)
+
+    starcat_source = property(get_starcat_source, set_starcat_source)
+
+    def reset(self):
+        self.set_date(None)
+        self.attitude = None
+        self.catalog_widget.reset()
+        # self.centroid_table.reset()
+
+    def set_catalog(self, catalog):
+        self.reset()
+
+        try:
+            logger.debug("Setting catalog")
+
+            self.date = catalog.date
+            self.attitude = catalog.att
+
+            table = Table()
+            table["slot"] = np.arange(8)
+            # table["id"] = np.ma.masked_all(8, dtype=int)
+            # table["yang"] = np.ma.masked_all(8, dtype=float)
+            # table["zang"] = np.ma.masked_all(8, dtype=float)
+            # table["mag"] = np.ma.masked_all(8, dtype=float)
+            # table["enabled"] = np.zeros(8, dtype=bool)
+            # table["fid"] = np.ma.masked_all(8, dtype=bool)
+            # table["type"] = np.ma.masked_all(8, dtype="<U3")
+            table["id"] = 0
+            table["yang"] = 0.0
+            table["zang"] = 0.0
+            table["mag"] = 0.0
+            table["enabled"] = False
+            table["fid"] = False
+            table["type"] = "   "  # 3 characters
+
+            guides = catalog[np.in1d(catalog["type"], ["GUI", "BOT", "FID"])]
+            idx = np.searchsorted(np.arange(8), guides["slot"])
+            table["slot"][idx] = guides["slot"]
+            table["id"][idx] = guides["id"]
+            table["yang"][idx] = guides["yang"]
+            table["zang"][idx] = guides["zang"]
+            table["mag"][idx] = guides["mag"]
+            table["type"][idx] = guides["type"]
+            table["enabled"][idx] = guides["type"] != "FID"
+            table["fid"][idx] = guides["type"] == "FID"
+
+            self.catalog_widget.set_centroids(table)
+
+            centroids = self.centroid_table.get_centroids().copy()
+            centroids["enabled"] = self.catalog_widget.get_centroids()["enabled"]
+            self.centroid_table.set_centroids(centroids)
+
+        except Exception as exc:
+            log_exception("Error setting catalog", exc)
+
+    def enable_slot(self, slot, enable):
+        self.catalog_widget.enable_slot(slot, enable)
+        centroids = self.centroid_table.get_centroids().copy()
+        centroids["enabled"] = self.catalog_widget.get_centroids()["enabled"]
+        self.centroid_table.set_centroids(centroids)
+
+    def set_centroids(self, centroids):
+        try:
+            if np.any(centroids["IMGNUM"] != np.arange(8)):
+                logger.warning("Got centroids that do not match")
+                return
+            fa_centroids = Table(centroids)
+            fa_centroids["enabled"] = self.catalog_widget.get_centroids()["enabled"]
+            fa_centroids.rename_columns(
+                ["IMGNUM", "YAGS", "ZAGS", "AOACMAG"],
+                ["slot", "yang", "zang", "mag"],
+            )
+            self.centroid_table.set_centroids(fa_centroids)
+            self.find_attitude()
+        except Exception as exc:
+            log_exception("Error setting centroids", exc, level="ERROR")
+
+    def find_attitude(self):
+        try:
+            if not self.tracking or self.attitude is None:
+                return
+
+            sel = self.centroid_table.get_centroids()["enabled"]
+            attitude = calc_att(
+                self.attitude,
+                self.catalog_widget.get_centroids()["yang"][sel],
+                self.catalog_widget.get_centroids()["zang"][sel],
+                self.centroid_table.get_centroids()["yang"][sel],
+                self.centroid_table.get_centroids()["zang"][sel],
+            )
+            self.attitude_updated.emit(attitude)
+        except Exception as exc:
+            log_exception("Error finding attitude", exc, level="ERROR")
diff --git a/aperoll/widgets/centroid_table.py b/aperoll/widgets/centroid_table.py
new file mode 100644
index 0000000..723e4c1
--- /dev/null
+++ b/aperoll/widgets/centroid_table.py
@@ -0,0 +1,165 @@
+import sys
+
+import numpy as np
+import PyQt5.QtCore as QtC
+import PyQt5.QtWidgets as QtW
+
+from aperoll.utils import logger
+from aperoll.widgets.table_widget import TableWidget
+
+FORMATS = {
+    "slot": "{:d}",
+    "yang": "{:8.2f}",
+    "zang": "{:8.2f}",
+    "mag": "{:5.2f}",
+}
+
+TYPES = {
+    "enable": bool,
+    "enabled": bool,
+    "id": int,
+    "fid": bool,
+    "mag": float,
+    "slot": int,
+    "type": "<U3",
+    "yang": float,
+    "zang": float,
+}
+
+
+class CentroidTable(TableWidget):
+    slot_enabled = QtC.pyqtSignal(int, bool)
+
+    def __init__(self, columns=None, titles=None, add_enable=True):
+        rows = 8
+        columns = (
+            ["slot", "yang", "zang", "mag", "enabled"] if columns is None else columns
+        )
+        titles = list(columns if titles is None else titles)  # this makes a copy
+        if add_enable and "enable" not in columns:
+            columns.insert(0, "enable")
+            titles.insert(0, "Enable")
+        super().__init__(
+            rows=rows,
+            columns=len(columns),
+            column_titles=titles,
+        )
+
+        self.format = {col: FORMATS.get(col, "{}") for col in columns}
+
+        self._table = np.zeros(rows, dtype=[(col, TYPES[col]) for col in columns])
+
+        # Set the enabled column to be as narrow as possible
+        if "enable" in columns:
+            idx = columns.index("enable")
+            self._q_table.horizontalHeader().setSectionResizeMode(
+                idx, QtW.QHeaderView.ResizeToContents
+            )
+
+            for row in range(rows):
+                checkbox = QtW.QCheckBox()
+                self._q_table.setCellWidget(row, idx, checkbox)
+                checkbox.setStyleSheet("margin-left: auto; margin-right: auto;")
+                checkbox.stateChanged.connect(
+                    lambda state, row=row: self.enable_slot(
+                        row, state == QtC.Qt.Checked
+                    )
+                )
+
+        # set all cell items to empty strings now to make sure the items are initialized
+        for row in range(rows):
+            for col in range(len(columns)):
+                colname = self._table.dtype.names[col]
+                if colname == "enable":
+                    continue
+                self._q_table.setItem(row, col, QtW.QTableWidgetItem(""))
+
+        self._reset_table()
+
+    def set_read_only(self, read_only):
+        for row in range(len(self._table)):
+            for col in range(len(self._table.dtype.names)):
+                item = self._q_table.item(row, col)
+                if item is not None:
+                    if read_only:
+                        item.setFlags(item.flags() ^ QtC.Qt.ItemIsEditable)
+                    else:
+                        item.setFlags(item.flags() | QtC.Qt.ItemIsEditable)
+
+    def reset(self):
+        self._reset_table()
+        self._display_table()
+
+    def _reset_table(self):
+        self._table[:] = 0
+        self._table["slot"] = np.arange(8)
+
+    def set_centroids(self, centroids):
+        self._reset_table()
+        if not np.all(centroids["slot"] == self._table["slot"]):
+            logger.debug(f"Got centroids that do not match: slot={centroids['slot']}")
+            return
+        if "enable" in self._table.dtype.names:
+            self._table["enable"] = centroids["enabled"]
+        for col in set(self._table.dtype.names).intersection(centroids.dtype.names):
+            self._table[col] = centroids[col]
+        self._display_table()
+
+    def get_centroids(self):
+        view = self._table.view()
+        view.flags.writeable = False
+        return view
+
+    def enable_slot(self, slot, enable):
+        if self._table["enable"][slot] == enable:
+            # nothing to do
+            return
+        self._table["enable"][slot] = enable
+        col = list(self._table.dtype.names).index("enable")
+        checkbox = self._q_table.cellWidget(slot, col)
+        checkbox.setChecked(enable)
+        self.slot_enabled.emit(slot, enable)
+
+    def _display_table(self):
+        for row in range(len(self._table)):
+            for col in range(len(self._table.dtype)):
+                colname = self._table.dtype.names[col]
+                item = self._table[row][col]
+                if colname == "enable":
+                    checkbox = self._q_table.cellWidget(row, col)
+                    checkbox.setChecked(item)
+                else:
+                    self._q_table.item(row, col).setText(
+                        self.format[colname].format(item)
+                    )
+
+
+if __name__ == "__main__":
+    app = QtW.QApplication(sys.argv)
+
+    centroids = np.array(
+        [
+            (0, True, -764.98, -1876.88, 7.06),
+            (1, True, 2146.43, 31.10, 7.19),
+            (2, True, -1819.00, 26.60, 7.19),
+            (3, False, 843.05, -1395.72, 7.88),
+            (4, False, -673.33, 755.15, 9.06),
+            (5, False, -686.73, 2047.40, 9.38),
+            (6, False, -682.90, -688.48, 10.31),
+            (7, False, -390.85, 1030.92, 9.31),
+        ],
+        dtype=[
+            ("IMGNUM", int),
+            ("IMGFID", bool),
+            ("YAGS", float),
+            ("ZAGS", float),
+            ("AOACMAG", float),
+        ],
+    )
+
+    widget = CentroidTable()
+    widget.resize(800, 600)
+    widget.set_centroids(centroids)
+    widget.show()
+
+    sys.exit(app.exec_())
diff --git a/aperoll/widgets/find_attitude_widget.py b/aperoll/widgets/find_attitude_widget.py
new file mode 100644
index 0000000..ffb3840
--- /dev/null
+++ b/aperoll/widgets/find_attitude_widget.py
@@ -0,0 +1,359 @@
+from pprint import pformat
+
+import numpy as np
+from astropy.table import Table
+from cxotime import CxoTime
+from find_attitude import Constraints, find_attitude_solutions
+from PyQt5 import QtCore as QtC
+from PyQt5 import QtWidgets as QtW
+from ska_sun import get_sun_pitch_yaw
+
+from aperoll.utils import AperollException, log_exception, logger
+from aperoll.widgets.attitude_widget import (
+    AttitudeWidget,
+    QuatRepresentation,
+    hstack,
+    vstack,
+)
+from aperoll.widgets.centroid_table import CentroidTable
+from aperoll.widgets.error_message import ErrorMessage
+from aperoll.widgets.line_edit import LineEdit
+
+
+class NoSolutionError(AperollException):
+    pass
+
+
+class Catalog(Table):
+    def __init__(self, date=None, att=None, **kwargs):
+        super().__init__(**kwargs)
+        self.date = date
+        self.att = att
+
+
+class OptionalParameter(QtW.QWidget):
+    def __init__(
+        self,
+        label,
+        widget=None,
+        parent=None,
+        enabled=False,
+        layout="v",
+        default="",
+        formatter=lambda val: f"{val}",
+        value_type=float,
+    ):
+        super().__init__(parent)
+        self.formatter = formatter
+        self.value_type = value_type
+        self.default = default
+        self.label = QtW.QLabel(label)
+        self.widget = LineEdit(self) if widget is None else widget
+        self.widget.setText(f"{default}")
+        self.widget.setEnabled(enabled)
+        self.checkbox = QtW.QCheckBox()
+        self.checkbox.setChecked(enabled)
+        stack = hstack if layout == "h" else vstack
+        hs = hstack(
+            self.checkbox,
+            self.label,
+            stretch=True,
+        )
+        hs.setSpacing(10)
+        hs.setContentsMargins(0, 0, 0, 0)
+        lyt = stack(
+            hs,
+            self.widget,
+        )
+        s = 0
+        lyt.setSpacing(0)
+        lyt.setContentsMargins(s, 0, s, 0)
+
+        self.setLayout(lyt)
+        self.checkbox.stateChanged.connect(self.setEnabled)
+
+    def setEnabled(self, enabled):
+        self.widget.setEnabled(enabled)
+        self.checkbox.setChecked(enabled)
+
+    def isEnabled(self):
+        return self.checkbox.isChecked()
+
+    enabled = property(isEnabled, setEnabled)
+
+    def setText(self, text):
+        self.widget.setText(text)
+
+    def setValue(self, value):
+        self.widget.setText(self.formatter(value))
+
+    def reset(self):
+        self.setValue(self.default)
+
+    def value(self):
+        return self.value_type(self.widget.text()) if self.enabled else None
+
+
+class FindAttitudeWidget(QtW.QWidget):
+    will_find_attitude = QtC.pyqtSignal()
+    found_attitude = QtC.pyqtSignal(Catalog)
+    slot_enabled = QtC.pyqtSignal(int, bool)
+
+    def __init__(self):
+        super().__init__()
+
+        self.date_edit = LineEdit(self)
+        self.date_edit.setReadOnly(True)
+        self.tolerance_edit = LineEdit(self)
+        self.tolerance_edit.setText("3")
+
+        self.rough_attitude_estimate = OptionalParameter(
+            "Rough Attitude Estimate (q1, q2, q3, q4)",
+            value_type=lambda val: np.array([float(x) for x in val.split(",")]),
+        )
+        self.sun_pitch = OptionalParameter("Sun Pitch (degrees)")
+        self.sun_pitch_sigma = OptionalParameter(
+            "Sun Pitch Uncertainty (degrees)", default=1.5
+        )
+        self.radial_uncertainty = OptionalParameter(
+            "Radial Uncertainty (degrees)", default=4.0
+        )
+        self.max_off_nominal_roll = OptionalParameter(
+            "Max Off-nominal roll (degrees)", default=2.0
+        )
+        self.min_n_stars = OptionalParameter("Min N stars", default=2)
+        self.max_mag_diff = OptionalParameter("Max Mag diff", default=1.5)
+
+        self.attitude_widget = AttitudeWidget(
+            self,
+            columns={
+                QuatRepresentation.EQUATORIAL: 0,
+                QuatRepresentation.QUATERNION: 0,
+                QuatRepresentation.SUN: 0,
+            },
+        )
+        self.attitude_widget.set_read_only(True)
+
+        self.centroid_table = CentroidTable()
+        self.centroid_table.setHorizontalScrollBarPolicy(QtC.Qt.ScrollBarAlwaysOff)
+        self.centroid_table.setMinimumWidth(100)
+
+        self.auto_update_params = QtW.QCheckBox()
+        self.update_params_button = QtW.QPushButton("Update Params")
+        self.find_attitude_button = QtW.QPushButton("Find Attitude")
+
+        self._set_layout()
+
+        self.update_params_button.clicked.connect(self.update_params)
+        self.find_attitude_button.clicked.connect(self.find_attitude)
+        self.centroid_table.slot_enabled.connect(self.slot_enabled)
+
+    def _set_layout(self):
+        date_box = QtW.QGroupBox("Date")
+        date_box.setLayout(
+            vstack(
+                self.date_edit,
+            )
+        )
+
+        button_box = QtW.QGroupBox()
+        button_box.setLayout(
+            hstack(
+                self.auto_update_params,
+                QtW.QLabel("auto-update params"),
+                QtW.QSpacerItem(
+                    0,
+                    0,
+                    hPolicy=QtW.QSizePolicy.Expanding,
+                    vPolicy=QtW.QSizePolicy.Minimum,
+                ),
+                self.update_params_button,
+                self.find_attitude_button,
+            )
+        )
+
+        tolerance_box = QtW.QGroupBox("Tolerance")
+        tolerance_box.setLayout(
+            vstack(
+                self.tolerance_edit,
+            )
+        )
+
+        att_box = QtW.QGroupBox("Latest Solution")
+        att_box.setLayout(
+            vstack(
+                self.attitude_widget,
+            )
+        )
+
+        table_box = QtW.QGroupBox("Star data")
+        table_box.setLayout(vstack(self.centroid_table))
+
+        other_box = QtW.QGroupBox("Advanced Parameters")
+        grid = QtW.QGridLayout()
+        grid.setContentsMargins(10, 10, 10, 0)
+        # grid.setSpacing(0)
+        grid.setVerticalSpacing(10)
+        grid.setHorizontalSpacing(0)
+
+        grid.addWidget(self.rough_attitude_estimate, 0, 0, 1, 2)
+        grid.addWidget(self.sun_pitch, 1, 0, 1, 1)
+        grid.addWidget(self.sun_pitch_sigma, 1, 1, 1, 1)
+        grid.addWidget(self.radial_uncertainty, 2, 0)
+        grid.addWidget(self.max_off_nominal_roll, 2, 1)
+        grid.addWidget(self.min_n_stars, 3, 0)
+        grid.addWidget(self.max_mag_diff, 3, 1)
+
+        other_box.setLayout(grid)
+
+        layout = QtW.QHBoxLayout()
+        layout.addStretch()
+        layout.addLayout(
+            vstack(
+                hstack(date_box, tolerance_box),
+                table_box,
+                other_box,
+                QtW.QSpacerItem(
+                    0,
+                    0,
+                    hPolicy=QtW.QSizePolicy.Minimum,
+                    vPolicy=QtW.QSizePolicy.Expanding,
+                ),
+                att_box,
+                button_box,
+                stretch=False,
+            )
+        )
+        layout.addStretch()
+        self.setLayout(layout)
+        self.reset()
+
+    def set_attitude(self, attitude):
+        if attitude is None:
+            self.rough_attitude_estimate.enabled = False
+            self.sun_pitch.enabled = False
+            self.sun_pitch_sigma.enabled = False
+            self.rough_attitude_estimate.reset()
+            self.sun_pitch.reset()
+        else:
+            q = ", ".join([f"{x:.12f}" for x in attitude.q])
+            self.rough_attitude_estimate.setText(q)
+            pitch, _ = get_sun_pitch_yaw(attitude.ra, attitude.dec, self.date)
+            self.sun_pitch.setText(f"{pitch:.2f}")
+
+    def get_attitude(self):
+        self.attitude_widget.get_attitude()
+
+    attitude = property(get_attitude, set_attitude)
+
+    def set_date(self, date):
+        date = CxoTime(date).date if date is not None else ""
+        if date != self.date_edit.text():
+            self.date_edit.setText(date)
+
+    def get_date(self):
+        text = self.date_edit.text()
+        if text:
+            return CxoTime(self.date_edit.text())
+
+    date = property(get_date, set_date)
+
+    def reset(self):
+        self.set_date(None)
+        self.attitude = None
+        self.centroid_table.reset()
+
+    def update_params(self):
+        self.set_date(None)
+        self.attitude = None
+        self.centroid_table.reset()
+
+    def set_centroids(self, centroids):
+        fa_centroids = Table(centroids)
+        fa_centroids["enabled"] = ~fa_centroids["IMGFID"]
+        fa_centroids.rename_columns(
+            ["IMGNUM", "YAGS", "ZAGS", "AOACMAG"],
+            ["slot", "yang", "zang", "mag"],
+        )
+        self.centroid_table.set_centroids(fa_centroids)
+
+    def enable_slot(self, slot, enable):
+        self.centroid_table.enable_slot(slot, enable)
+
+    def find_attitude(self):
+        try:
+            logger.debug("Find Attitude")
+            self.will_find_attitude.emit()
+            self.attitude_widget.set_attitude(None)
+
+            constraints = self.get_constraints()
+            constraints = Constraints(**constraints)
+
+            stars = self.centroid_table.get_centroids()
+            stars = Table(
+                stars[stars["enable"]][["slot", "yang", "zang", "mag", "enabled"]]
+            )
+            stars.rename_columns(
+                ["yang", "zang", "mag"],
+                ["YAG", "ZAG", "MAG_ACA"],
+            )
+
+            logger.debug("Star data")
+            logger.debug("\n" + "\n".join(stars.pformat()))
+            logger.debug("Constraints")
+            logger.debug("\n" + pformat(constraints))
+
+            solutions = find_attitude_solutions(
+                np.asarray(stars),
+                tolerance=float(self.tolerance_edit.text()),
+                constraints=constraints,
+            )
+            if not solutions:
+                raise NoSolutionError("No solutions found")
+            logger.debug(f"Found {len(solutions)} solutions")
+
+            solution = solutions[0]
+            catalog = Catalog(
+                date=self.date,
+                att=solution["att_fit"],
+            )
+            table = solution["summary"][~solution["summary"]["m_agasc_id"].mask]
+            catalog["slot"] = table["slot"]
+            catalog["id"] = table["m_agasc_id"]
+            catalog["type"] = "GUI"
+            catalog["yang"] = table["m_yag"]
+            catalog["zang"] = table["m_zag"]
+            catalog["mag"] = table["m_mag"]
+
+            self.attitude_widget.set_attitude(solution["att_fit"])
+
+            # centroids are reset to update the "enabled" status
+            new_centroids = self.centroid_table.get_centroids().copy()
+            new_centroids["enabled"] = [
+                slot in catalog["slot"] for slot in new_centroids["slot"]
+            ]
+            self.centroid_table.set_centroids(new_centroids)
+
+            self.found_attitude.emit(catalog)
+        except NoSolutionError as exc:
+            log_exception("No solutions found", exc, level="ERROR")
+            error_dialog = ErrorMessage(title="Error", message=str(exc))
+            error_dialog.exec()
+        except Exception as exc:
+            log_exception("Error finding attitude", exc, level="ERROR")
+            error_dialog = ErrorMessage(
+                title="Error finding attitude", message=str(exc)
+            )
+            error_dialog.exec()
+
+    def get_constraints(self):
+        parameters = {
+            "att": self.rough_attitude_estimate.value(),
+            "pitch": self.sun_pitch.value(),
+            "pitch_err": self.sun_pitch_sigma.value(),
+            "att_err": self.radial_uncertainty.value(),
+            "off_nom_roll_max": self.max_off_nominal_roll.value(),
+            "min_stars": self.min_n_stars.value(),
+            "mag_err": self.max_mag_diff.value(),
+        }
+        return parameters
diff --git a/aperoll/widgets/star_plot.py b/aperoll/widgets/star_plot.py
index b2ae2fd..32bdd34 100644
--- a/aperoll/widgets/star_plot.py
+++ b/aperoll/widgets/star_plot.py
@@ -798,6 +798,7 @@ def set_centroids(self, centroids):
     def include_slot(self, slot, include):
         self.view.include_slot(slot, include)
 
+
 def main():
     from aperoll.utils import get_default_parameters
 
diff --git a/aperoll/widgets/table_widget.py b/aperoll/widgets/table_widget.py
new file mode 100644
index 0000000..9092bb3
--- /dev/null
+++ b/aperoll/widgets/table_widget.py
@@ -0,0 +1,61 @@
+import sys
+
+import PyQt5.QtWidgets as QtW
+
+
+class TableWidget(QtW.QWidget):
+    def __init__(self, rows, columns, column_titles, parent=None):
+        super().__init__(parent)
+
+        self._q_table = QtW.QTableWidget(rows, columns, self)
+        self._q_table.setHorizontalHeaderLabels(column_titles)
+
+        layout = QtW.QVBoxLayout()
+        layout.addWidget(self._q_table)
+        layout.setContentsMargins(0, 0, 0, 0)  # Remove margins
+        layout.setSpacing(0)  # Remove spacing
+        self.setLayout(layout)
+
+        self._q_table.horizontalHeader().setStretchLastSection(True)
+        self._q_table.horizontalHeader().setSectionResizeMode(QtW.QHeaderView.Stretch)
+        self._q_table.verticalHeader().setSectionResizeMode(QtW.QHeaderView.Stretch)
+
+        # Hide the headers (row/column numbers)
+        self._q_table.verticalHeader().setVisible(False)
+        # self._q_table.horizontalHeader().setVisible(False)
+
+        # Calculate and set the minimum size
+        self.setMinimumSize(*self.calculate_minimum_size())
+
+    def calculate_minimum_size(self):
+        width = self._q_table.verticalHeader().width()
+        height = self._q_table.horizontalHeader().height()
+
+        for col in range(self._q_table.columnCount()):
+            width += self._q_table.columnWidth(col)
+
+        for row in range(self._q_table.rowCount()):
+            height += self._q_table.rowHeight(row)
+
+        return width, height
+
+    def resizeEvent(self, event):
+        self._q_table.resize(self.size())
+        super().resizeEvent(event)
+
+    def setHorizontalScrollBarPolicy(self, policy):
+        self._q_table.setHorizontalScrollBarPolicy(policy)
+
+
+if __name__ == "__main__":
+    app = QtW.QApplication(sys.argv)
+
+    rows = 10
+    columns = 5
+    column_titles = ["Column 1", "Column 2", "Column 3", "Column 4", "Column 5"]
+
+    widget = TableWidget(rows, columns, column_titles)
+    widget.resize(800, 600)
+    widget.show()
+
+    sys.exit(app.exec_())
diff --git a/aperoll/widgets/telemetry_view.py b/aperoll/widgets/telemetry_view.py
new file mode 100644
index 0000000..8f93d64
--- /dev/null
+++ b/aperoll/widgets/telemetry_view.py
@@ -0,0 +1,492 @@
+import functools
+import pprint
+
+import numpy as np
+from cxotime import CxoTime
+from PyQt5 import QtCore as QtC
+from PyQt5 import QtWidgets as QtW
+from ska_sun import get_sun_pitch_yaw
+
+from aperoll.proseco_data import ProsecoData
+from aperoll.utils import logger
+from aperoll.widgets.attitude_widget import (
+    AttitudeWidget,
+    QuatRepresentation,
+    TextEdit,
+    hstack,
+    vstack,
+)
+from aperoll.widgets.catalog_widget import CatalogWidget
+from aperoll.widgets.error_message import ErrorMessage
+from aperoll.widgets.find_attitude_widget import FindAttitudeWidget
+from aperoll.widgets.line_edit import LineEdit
+from aperoll.widgets.proseco_params import ProsecoParams
+from aperoll.widgets.star_plot import StarPlot
+from aperoll.widgets.starcat_review import StarcatReview
+
+
+class TelemetryView(QtW.QWidget):
+    def __init__(self):  # noqa: PLR0915
+        super().__init__()
+
+        self.create_widgets()
+        self.set_connections()
+        self.set_layout()
+
+    def create_widgets(self):
+        """
+        Creates all the widgets.
+        """
+        self.data = ProsecoData()
+
+        self.star_plot = StarPlot(self)
+        self.star_plot.scene.state = "Telemetry"
+        self.star_plot.view.setBackgroundBrush(QtC.Qt.white)
+
+        self.starcat_review = StarcatReview()
+        self.catalog_widget = CatalogWidget()
+        self.find_attitude_widget = FindAttitudeWidget()
+        self.date_edit = LineEdit(self)
+        self.date_edit.setReadOnly(True)
+        self.obsid_edit = LineEdit(self)
+        self.obsid_edit.setReadOnly(True)
+        self.t_ccd_edit = LineEdit(self)
+        self.t_ccd_edit.setReadOnly(True)
+        self.onboard_attitude_widget = AttitudeWidget(
+            self,
+            columns={
+                QuatRepresentation.EQUATORIAL: 0,
+                QuatRepresentation.QUATERNION: 0,
+                QuatRepresentation.SUN: 0,
+            },
+        )
+        self.onboard_attitude_widget.set_read_only(True)
+        self.view_attitude_widget = AttitudeWidget(
+            self,
+            columns={
+                QuatRepresentation.EQUATORIAL: 0,
+                QuatRepresentation.QUATERNION: 0,
+                QuatRepresentation.SUN: 0,
+            },
+        )
+        self.delta_q_edit = TextEdit(size=4)
+        self.delta_sun_pitch_edit = LineEdit(self)
+        self.rasl_edit = LineEdit(self)
+
+        self.delta_q_edit.setReadOnly(True)
+        self.delta_sun_pitch_edit.setReadOnly(True)
+        self.rasl_edit.setReadOnly(True)
+
+        self.proseco_params_widget = ProsecoParams(show_buttons=True)
+        self.instrument_edit = QtW.QComboBox(self)
+        self.instrument_edit.addItems(["ACIS-S", "ACIS-I", "HRC-S", "HRC-I"])
+
+        self.get_catalog_button = QtW.QPushButton("Select Catalog")
+        self.find_attitude_button = QtW.QPushButton("Find Attitude")
+
+        self.user_attitude_button = QtW.QRadioButton("User")
+        self.telemetry_attitude_button = QtW.QRadioButton("Telemetry")
+        self.track_attitude_button = QtW.QRadioButton("ACA Centroids")
+
+        self.telemetry_attitude_button.setChecked(True)
+
+        self._telemetry_source_buttons = [
+            QtW.QRadioButton("Telemetry"),
+            QtW.QRadioButton("User"),
+            QtW.QRadioButton("Find Attitude"),
+        ]
+
+        self.attitude_source_group = QtW.QButtonGroup()
+        for idx, button in enumerate(self._telemetry_source_buttons):
+            self.attitude_source_group.addButton(button)
+            self.attitude_source_group.setId(button, idx)
+
+        self.attitude_source_group_index = {
+            button.text(): idx
+            for idx, button in enumerate(self.attitude_source_group.buttons())
+        }
+
+        self.attitude_source = "Telemetry"
+
+    def get_attitude_source(self):
+        return self.attitude_source_group.checkedButton().text()
+
+    def set_attitude_source(self, source):
+        self.attitude_source_group.button(
+            self.attitude_source_group_index[source]
+        ).setChecked(True)
+        if source == "Telemetry":
+            # changing the attitude source to "Telemetry" has the immediate effect of changing
+            # the view attitude to match the onboard attitude
+            self.set_view_attitude(self.onboard_attitude_widget.attitude)
+            # and any new change to the onboard attitude will change the view attitude
+            self.star_plot.scene.onboard_attitude_slot = "attitude"
+        else:
+            self.star_plot.scene.onboard_attitude_slot = "alternate_attitude"
+
+    attitude_source = property(get_attitude_source, set_attitude_source)
+
+    def get_starcat_source(self):
+        return self.catalog_widget.starcat_source
+
+    def set_starcat_source(self, source):
+        self.catalog_widget.starcat_source = source
+
+    starcat_source = property(get_starcat_source, set_starcat_source)
+
+    def set_connections(self):
+        """
+        Connects signals to slots.
+        """
+
+        # connect widgets to proseco params
+        self.date_edit.value_changed.connect(self.proseco_params_widget.set_date)
+        self.onboard_attitude_widget.attitude_changed.connect(self._update_delta_quat)
+        self.view_attitude_widget.attitude_changed.connect(self.set_view_attitude)
+        self.star_plot.attitude_changed.connect(self.set_view_attitude)
+        self.catalog_widget.attitude_updated.connect(self.set_view_attitude)
+        self.view_attitude_widget.attitude_changed.connect(self._set_user_attitude)
+        self.star_plot.attitude_changed.connect(self._set_user_attitude)
+        self.obsid_edit.value_changed.connect(
+            functools.partial(self.proseco_params_widget.set_obsid)
+        )
+        self.instrument_edit.currentTextChanged.connect(
+            functools.partial(self.proseco_params_widget.__setitem__, "detector")
+        )
+
+        # connect buttons
+        self.get_catalog_button.clicked.connect(
+            lambda _check: self._get_catalog(interactive=True)
+        )
+
+        self.attitude_source_group.buttonClicked.connect(
+            lambda button: self.set_attitude_source(button.text())
+        )
+
+        self.find_attitude_widget.slot_enabled.connect(self.star_plot.include_slot)
+        self.star_plot.slot_included.connect(self.find_attitude_widget.enable_slot)
+        self.catalog_widget.slot_enabled.connect(self.star_plot.include_slot)
+        self.star_plot.slot_included.connect(self.catalog_widget.enable_slot)
+        self.star_plot.star_included.connect(self.proseco_params_widget.include_star)
+
+        self.find_attitude_widget.found_attitude.connect(self._attitude_found)
+
+        for button in self._telemetry_source_buttons:
+            if button.text() == "Find Attitude":
+                button.clicked.connect(self._find_attitude)
+                break
+
+        # when find_attitude is called, we want to reset the catalog review
+        self.find_attitude_widget.will_find_attitude.connect(self._reset)
+
+    def set_layout(self):
+        """
+        Arranges the widgets.
+        """
+        self.main_tab = QtW.QTabWidget()
+
+        general_info_layout = QtW.QGridLayout()
+        general_info_layout.addWidget(QtW.QLabel("OBSID"), 0, 0, 1, 1)
+        general_info_layout.addWidget(self.obsid_edit, 0, 1, 1, 2)
+        general_info_layout.addWidget(QtW.QLabel("date"), 1, 0, 1, 1)
+        general_info_layout.addWidget(self.date_edit, 1, 1, 1, 2)
+        general_info_layout.addWidget(QtW.QLabel("T_CCD"), 2, 0, 1, 1)
+        general_info_layout.addWidget(self.t_ccd_edit, 2, 1, 1, 2)
+        general_info_layout.addWidget(QtW.QLabel("instrument"), 3, 0, 1, 1)
+        general_info_layout.addWidget(self.instrument_edit, 3, 1, 1, 2)
+
+        controls_group_box = QtW.QGroupBox()
+        controls_group_box.setLayout(
+            hstack(self.get_catalog_button, self.find_attitude_button),
+        )
+
+        v_layout_left = QtW.QVBoxLayout()
+        v_layout_right = QtW.QVBoxLayout()
+
+        info_box = QtW.QGroupBox("Info")
+        info_box.setLayout(general_info_layout)
+        v_layout_left.addWidget(info_box)
+
+        onboard_att_box = QtW.QGroupBox("On-board Attitude")
+        onboard_att_box.setLayout(hstack(self.onboard_attitude_widget))
+        v_layout_right.addWidget(onboard_att_box)
+
+        grid = QtW.QGridLayout()
+        cols = 3
+        for idx, button in enumerate(self.attitude_source_group.buttons()):
+            grid.addWidget(button, idx // cols, idx % cols)
+
+        view_att_box = QtW.QGroupBox("View Attitude")
+        view_att_box.setLayout(vstack(self.view_attitude_widget, grid))
+        v_layout_right.addWidget(view_att_box)
+
+        delta_quat_group_box = QtW.QGroupBox("Delta Quaternion")
+        delta_quat_group_box.setLayout(
+            hstack(
+                vstack(
+                    QtW.QLabel("Sun Pitch"),
+                    QtW.QLabel("Sun Yaw (RASL)"),
+                    QtW.QLabel("Quaternion"),
+                    stretch=True,
+                    spacing=15,
+                ),
+                vstack(
+                    self.delta_sun_pitch_edit,
+                    self.rasl_edit,
+                    self.delta_q_edit,
+                    stretch=True,
+                ),
+            )
+        )
+        v_layout_right.addWidget(delta_quat_group_box)
+        v_layout_right.addStretch(1)
+        v_layout_left.addStretch(1)
+        v_layout_left.addWidget(controls_group_box)
+
+        self.main_tab.addTab(self.star_plot, "Star Plot")
+        self.main_tab.addTab(self.find_attitude_widget, "Find Attitude")
+        self.main_tab.addTab(self.proseco_params_widget, "Proseco Parameters")
+        self.main_tab.addTab(self.starcat_review, "Catalog")
+        self.main_tab.addTab(self.catalog_widget, "Tracking")
+
+        layout = QtW.QHBoxLayout()
+        layout.addLayout(v_layout_left, 1)
+        layout.addWidget(self.main_tab, 3)
+        layout.addLayout(v_layout_right, 1)
+
+        self.setLayout(layout)
+
+    def _set_user_attitude(self):
+        self.attitude_source = "User"
+
+    def _find_attitude(self):
+        # catalog should be cleared before setting new catalog, in case there is an error
+        self.catalog_widget.reset()
+        self.find_attitude_widget.find_attitude()
+
+    def _attitude_found(self, solution):
+        logger.debug("Solution found")
+        logger.debug(solution.att)
+        logger.debug(solution.date)
+        logger.debug(pprint.pformat(solution))
+        self.attitude_source = "Find Attitude"
+        self.catalog_widget.set_catalog(solution)
+        self.set_view_attitude(solution.att)
+
+    def _include_star(self, star_id, action, include):
+        print(f"Include star {star_id} {action} {include}")
+
+    def _include_slot(self, slot_id, include):
+        print(f"Include slot {slot_id} {include}")
+
+    def _get_catalog(self, interactive=True):
+        try:
+            # catalog should be cleared before setting new catalog, in case there is an error
+            self.data.parameters = self.proseco_params_widget._parameters
+            if self.data.proseco:
+                self.starcat_source = "Proseco"
+                self.set_catalog(self.data.proseco["catalog"], "Proseco")
+        except Exception as exc:
+            if interactive:
+                msg = ErrorMessage(title="Error", message=str(exc))
+                msg.exec()
+
+    def _reset(self):
+        self.starcat_review.reset()
+
+    def set_catalog(self, catalog, source):
+        if self.starcat_source == source:
+            self.starcat_review.set_catalog(catalog)
+            self.catalog_widget.set_catalog(catalog)
+            self.star_plot.set_catalog(catalog)
+
+    def set_time(self, time):
+        self.proseco_params_widget.set_date(time, emit=True)
+        self.star_plot.set_time(time)
+        self.onboard_attitude_widget.set_date(time)
+        self.view_attitude_widget.set_date(time)
+        self.date_edit.setText(CxoTime(time).date)
+        self._update_delta_quat()
+        self.find_attitude_widget.set_date(time)
+
+    def set_centroids(self, centroids):
+        self.star_plot.set_centroids(centroids)
+        self.find_attitude_widget.set_centroids(centroids)
+        self.catalog_widget.set_centroids(centroids)
+
+    def set_onboard_attitude(self, att):
+        self.onboard_attitude_widget.set_attitude(att)
+        self.star_plot.set_onboard_attitude(att)
+        self.find_attitude_widget.set_attitude(att)
+        if self.attitude_source == "Telemetry":
+            self.set_view_attitude(att)
+        self._update_delta_quat()
+
+    def set_view_attitude(self, attitude):
+        # proseco_params_widget should not emit a signal when we drag the star field,
+        # because we do not want to trigger a new proseco call if auto_proseco is True
+        self.proseco_params_widget.set_attitude(attitude, emit=False)
+        self.view_attitude_widget.set_attitude(attitude)
+        self.star_plot.set_base_attitude(attitude)
+        self._update_delta_quat()
+
+    def set_telemetry(self, telemetry):
+        if not isinstance(telemetry["COBSRQID"], np.ma.core.MaskedConstant):
+            self.proseco_params_widget.set_obsid(telemetry["COBSRQID"])
+            self.obsid_edit.setText(str(telemetry["COBSRQID"]))
+        if not isinstance(telemetry["AACCCDPT"], np.ma.core.MaskedConstant):
+            t_ccd = telemetry["AACCCDPT"] - 273.15
+            self.t_ccd_edit.setText(f"{t_ccd:.2f}")
+            self.proseco_params_widget.set_t_ccd(t_ccd)
+
+    def _update_delta_quat(self):
+        if (
+            self.onboard_attitude_widget.attitude is None
+            or self.view_attitude_widget.attitude is None
+        ):
+            return
+        # dq is the quaternion such that:
+        # view_attitude = onboard_attitude * dq
+        dq = self.onboard_attitude_widget.attitude.dq(
+            self.view_attitude_widget.attitude
+        )
+        self.delta_q_edit.set_values(dq.q)
+
+        date = self.date_edit.text().strip()
+        if date:
+            date = CxoTime(date)
+            onboard_pitch, onboard_yaw = get_sun_pitch_yaw(
+                self.onboard_attitude_widget.attitude.ra,
+                self.onboard_attitude_widget.attitude.dec,
+                date,
+            )
+            view_pitch, view_yaw = get_sun_pitch_yaw(
+                self.view_attitude_widget.attitude.ra,
+                self.view_attitude_widget.attitude.dec,
+                date,
+            )
+            self.delta_sun_pitch_edit.setText(f"{view_pitch - onboard_pitch:.2f}")
+            self.rasl_edit.setText(f"{view_yaw - onboard_yaw:.2f}")
+
+
+def _test_data():
+    # example data to test the display
+    from Quaternion import Quat
+
+    telem = np.array(
+        (
+            8.47854822e08,
+            1.6959999,
+            8.47854823e08,
+            28843,
+            4,
+            99810,
+            36,
+            -0.76007281,
+            -0.30605962,
+            -0.1090998,
+            0.56277355,
+            "NPNT",
+            "KALM",
+            273.15,
+            0,
+            0,
+            "ORIG",
+            "DYNB",
+            12775716,
+            "2024292",
+            "2024:318:02:40:22.946",
+        ),
+        dtype=[
+            ("TIME", "<f8"),
+            ("INTEG", "<f4"),
+            ("END_INTEG_TIME", "<f8"),
+            ("COBSRQID", "<u4"),
+            ("AOKALSTR", "i1"),
+            ("MJF", "<u4"),
+            ("MNF", "u1"),
+            ("AOATTQT1", "<f8"),
+            ("AOATTQT2", "<f8"),
+            ("AOATTQT3", "<f8"),
+            ("AOATTQT4", "<f8"),
+            ("AOPCADMD", "<U4"),
+            ("AOACASEQ", "<U4"),
+            ("AACCCDPT", "<f8"),
+            ("COMMCNT", "u1"),
+            ("COMMPROG", "u1"),
+            ("AAPIXTLM", "<U4"),
+            ("AABGDTYP", "<U4"),
+            ("VCDUCTR", "<u4"),
+            ("dark_cal_id", "<U7"),
+            ("starcat_date", "<U21"),
+        ],
+    )
+    time = "2024:318:03:12:32.530"
+    q = Quat(
+        [
+            -0.7600728109882766,
+            -0.30605961532546644,
+            -0.10909980369319783,
+            0.5627735485595622,
+        ]
+    )
+    centroids = np.array(
+        [
+            (0, 155.0, -377.0, 155, -377, 7.0625, -764.975, -1876.875, True),
+            (1, -430.0, 8.0, -430, 8, 7.1875, 2146.425, 31.1, True),
+            (2, 368.0, 6.0, 368, 6, 7.1875, -1819.0, 26.6, True),
+            (3, -168.0, -279.0, -168, -279, 7.875, 843.05, -1395.725, False),
+            (4, 137.0, 152.0, 137, 152, 9.0625, -673.325, 755.15, False),
+            (5, 141.0, 413.0, 141, 413, 9.375, -686.725, 2047.4, False),
+            (6, 139.0, -137.0, 139, -137, 10.3125, -682.9, -688.475, False),
+            (7, 81.0, 208.0, 81, 208, 9.3125, -390.85, 1030.925, False),
+        ],
+        dtype=[
+            ("IMGNUM", "<i8"),
+            ("IMGROW0_8X8", "<f8"),
+            ("IMGCOL0_8X8", "<f8"),
+            ("IMGROW0", "<i8"),
+            ("IMGCOL0", "<i8"),
+            ("AOACMAG", "<f8"),
+            ("YAGS", "<f8"),
+            ("ZAGS", "<f8"),
+            ("IMGFID", "?"),
+        ],
+    )
+    return {"telemetry": telem, "time": time, "q": q, "centroids": centroids}
+
+
+if __name__ == "__main__":
+    import logging
+    import os
+    import sys
+
+    from aca_view import resources
+
+    sys.path.insert(0, os.path.dirname(resources.__file__))
+
+    import qdarkstyle  # type: ignore[missing-import]
+
+    # this is just a simple and quick way to test the widget, not intended for normal use.
+    logger.setLevel("DEBUG")
+
+    # find_attitude logger has level="INFO" by default
+    # I would rather redirect that logger's info into debug.
+    logging.getLogger("find_attitude").setLevel(logging.WARNING)
+
+    app = QtW.QApplication([])
+    app.setStyleSheet(qdarkstyle.load_stylesheet())
+
+    widget = QtW.QMainWindow()
+    telemetry_view = TelemetryView()
+    widget.setCentralWidget(telemetry_view)
+    widget.resize(1400, 800)
+
+    test_data = _test_data()
+    telemetry_view.set_time(test_data["time"])
+    telemetry_view.set_onboard_attitude(test_data["q"])
+    telemetry_view.set_centroids(test_data["centroids"])
+    telemetry_view.set_telemetry(test_data["telemetry"])
+
+    widget.show()
+    app.exec()
diff --git a/ruff-base.toml b/ruff-base.toml
index 836205f..8e9a25a 100644
--- a/ruff-base.toml
+++ b/ruff-base.toml
@@ -1,5 +1,4 @@
-# Copied originally from pandas. This config requires ruff >= 0.2.
-target-version = "py311"
+target-version = "py312"
 
 # fix = true
 lint.unfixable = []
@@ -31,6 +30,7 @@ lint.extend-select = [
 "ARG001",  # Unused function argument
 "RSE102",  # Unnecessary parentheses on raised exception
 "PERF401",  # Use a list comprehension to create a transformed list
+"S101",  # Use of `assert` detected
 ]
 
 lint.ignore = [
@@ -41,10 +41,13 @@ lint.ignore = [
   "B028", # No explicit `stacklevel` keyword argument found
   "PLR0913", # Too many arguments to function call
   "PLR1730", # Checks for if statements that can be replaced with min() or max() calls
+  "PLC0415", # `import` should be at the top-level of a file
+  "PLW1641", # Class implements `__hash__` if `__eq__` is implemented
 ]
 
 extend-exclude = [
   "docs",
+  "build",
 ]
 
 [lint.pycodestyle]
@@ -56,4 +59,5 @@ max-line-length = 100 # E501 reports lines that exceed the length of 100.
 # - D205: Don't worry about test docstrings
 # - ARG001: Unused function argument false positives for some fixtures
 # - E501: Line-too-long
-"**/tests/test_*.py" = ["D205", "ARG001", "E501"]
+# - S101: Do not use assert
+"**/tests/test_*.py" = ["D205", "ARG001", "E501", "S101"]