diff --git a/cmake/cpp.cmake b/cmake/cpp.cmake
index 2d11b35..8a3e41b 100644
--- a/cmake/cpp.cmake
+++ b/cmake/cpp.cmake
@@ -1,6 +1,6 @@
 #
 #	This file is for:
-#	- Encapsulating some platform differences
+#	- Encapsulating some platform and compiler differences
 #	- Source declaration
 #	- Qt6 dependency declaration
 #
@@ -16,12 +16,23 @@ set(APP_SOURCES
 set(OTHER_APP_SOURCES
 	"${CMAKE_SOURCE_DIR}/src/App/Recreation.cpp")
 
-set(WIDGET_SOURCES
+set(WINDOWING_SOURCES
 	"${WINDOWING_SRC_DIR}/DevWindow.cpp"
-	"${WINDOWING_SRC_DIR}/NumericTestWidget.cpp"
+	"${WINDOWING_SRC_DIR}/NumericTestWidget.cpp")
+
+set(DIAL_SOURCES
+	"${WIDGETS_SRC_DIR}/Dial/Attitude.cpp"
+	"${WIDGETS_SRC_DIR}/Dial/Composite.cpp")
+
+set(DISPLAYER_SOURCES
 	"${WIDGETS_SRC_DIR}/Displays/QuantitiesRatesDisplay.cpp"
 	"${WIDGETS_SRC_DIR}/Displays/QuantitiesRatesRow.cpp"
-	"${WIDGETS_SRC_DIR}/Dial/AttitudeDial.cpp")
+	"${WIDGETS_SRC_DIR}/Displays/RateLabel.cpp")
+
+set(WIDGET_SOURCES
+	${WINDOWING_SOURCES}
+	${DIAL_SOURCES}
+	${DISPLAYER_SOURCES})
 
 set(PLOTTING_SOURCES
 	"${PLOTTING_SRC_DIR}/Plot2D.cpp"
diff --git a/src/Plotting/Backend/CoreQChart.cpp b/src/Plotting/Backend/CoreQChart.cpp
index 9ed336c..33c7326 100644
--- a/src/Plotting/Backend/CoreQChart.cpp
+++ b/src/Plotting/Backend/CoreQChart.cpp
@@ -123,10 +123,10 @@ void PlotQChart::Plot() {
 
 		QList<QPointF> pts;
 		const SeriesInfo& sinfo = sinfos[idx];
-		unsigned int n = sinfo.Times.size();
+		std::size_t n = sinfo.Times.size();
 		if (n == 0) { continue; }
 
-		for (unsigned int i = 0; i < n; i++) {
+		for (unsigned int i = 0; static_cast<std::size_t>(i) < n; i++) {
 			pts.append({ sinfo.Times[i], sinfo.Quantities[i] });
 		}
 
diff --git a/src/Plotting/Plot2D.cpp b/src/Plotting/Plot2D.cpp
index ba62f59..6480ed5 100644
--- a/src/Plotting/Plot2D.cpp
+++ b/src/Plotting/Plot2D.cpp
@@ -4,7 +4,7 @@
 
 namespace VSCL::Plot {
 
-void EmbeddablePlot2D::AddPoint(double time, double quantity, bool update) { AddPoint(0, time, quantity); }
+void EmbeddablePlot2D::AddPoint(double time, double quantity, bool update) { AddPoint(0, time, quantity, update); }
 void EmbeddablePlot2D::AddPoint(uint8_t idx, double time, double quantity, bool update) {
 	std::vector<double>& oldTime = Series[idx].Times;
 	std::vector<double>& oldQty = Series[idx].Quantities;
@@ -19,8 +19,8 @@ void EmbeddablePlot2D::AddPoints(uint8_t idx,
 	std::vector<double>& oldTime = Series[idx].Times;
 	std::vector<double>& oldQty = Series[idx].Quantities;
 
-	oldTime.resize(oldTime.size() + times.size());
-	oldQty.resize(oldQty.size() + quantities.size());
+	oldTime.reserve(oldTime.size() + times.size());
+	oldQty.reserve(oldQty.size() + quantities.size());
 
 	for (double time : times) {
 		oldTime.push_back(time);
@@ -34,7 +34,7 @@ void EmbeddablePlot2D::AddPoints(uint8_t idx,
 }
 void EmbeddablePlot2D::AddPoints(
 		const std::vector<double>& times, const std::vector<double>& quantities, bool update) {
-			AddPoints(0, times, quantities); }
+			AddPoints(0, times, quantities, update); }
 
 void EmbeddablePlot2D::SetAxis(const Axis axis, const AxisInfo& info) {
 	switch (axis) {
diff --git a/src/Util/FiniteDiff.hpp b/src/Util/FiniteDiff.hpp
new file mode 100644
index 0000000..4eac491
--- /dev/null
+++ b/src/Util/FiniteDiff.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <array>
+
+namespace VSCL::Util {
+
+static constexpr double CenterFiniteDifference(const std::array<double, 3>& ts, const std::array<double, 3>& qtys) {
+	double h = (ts[2] - ts[0]) / 2.0;
+	double fwd = (qtys[2] - qtys[1]) / 2.0;
+	double bkd = (qtys[1] - qtys[0]) / 2.0;
+	
+	return (fwd - bkd) / h;
+}
+} // namespace VSCL::Util
diff --git a/src/Util/Sizing.hpp b/src/Util/Sizing.hpp
index 0e415c7..bc8f56f 100644
--- a/src/Util/Sizing.hpp
+++ b/src/Util/Sizing.hpp
@@ -4,12 +4,21 @@
 
 namespace VSCL::Util {
 
-constexpr int MinimumWidth = 720;
-constexpr int MinimumHeight = 480;
+static constexpr int MinimumWidth = 720;
+static constexpr int MinimumHeight = 480;
 
 struct FontAdjustment {
-	int PointSizeAtMinimum;
+	/*
+	 *	The point size at the window's minimum resolution.
+	 */
+	unsigned int PointSizeAtMinimum = 12;
+
+	/*
+	 *	When true, adjust to the width of the window.
+	 *	When false, adjust to the height of the window.
+	 */
 	bool AdjustToWidth = false;
+
 	const int AdjustPointSize(QWidget* win) const {
 		return PointSizeAtMinimum
 			+ ((AdjustToWidth) ?
diff --git a/src/Widgets/Dial/AttitudeDial.cpp b/src/Widgets/Dial/Attitude.cpp
similarity index 58%
rename from src/Widgets/Dial/AttitudeDial.cpp
rename to src/Widgets/Dial/Attitude.cpp
index 1ab8d2e..022f309 100644
--- a/src/Widgets/Dial/AttitudeDial.cpp
+++ b/src/Widgets/Dial/Attitude.cpp
@@ -1,29 +1,14 @@
 #include <QBoxLayout>
 #include <QPainter>
-
-#include <algorithm>
-#include <cmath>
-
-#include "AttitudeDial.hpp"
+#include "Attitude.hpp"
 
 namespace VSCL {
 
 AttitudeDial::AttitudeDial(QWidget* parent) : QWidget(parent) {
-	NumericDisplayFont = QFont();
-	NumericDisplay = new QLabel(this);
-	NumericDisplay->setBuddy(this);
-	NumericDisplay->setAlignment(Qt::AlignCenter);
-	NumericDisplay->setFrameStyle(QFrame::Panel | QFrame::Raised);
-	NumericDisplay->setFont(NumericDisplayFont);
-	NumericDisplay->setStyleSheet(" QLabel { color: white; background-color: black; border-radius: 3% } ");
-
+	SetRangeType(RangeTypeMode);
 	update();
 } // AttitudeDial ctor
 
-AttitudeDial::AttitudeDial(QWidget* parent, bool showNumericDisplay) : AttitudeDial(parent) {
-	SetNumericDisplayState(showNumericDisplay);
-}
-
 void AttitudeDial::SetDialAngle(double value) {
 	CurrentAngle = value;
 	update();
@@ -43,29 +28,38 @@ void AttitudeDial::UpdateOrigin() {
 	Origin = { curSize.width() / 2, curSize.height() / 2 };
 }
 
-void AttitudeDial::UpdateNumericDisplay() {
-	NumericDisplay->setText(QString::number(CurrentAngle) + "°");
+QPoint AttitudeDial::HandEndingLowestNominal() const {
+	double ang = (CurrentAngle - Range[0]) * 3.14 / 180.0;
+	int linex = Radius*std::sin(ang);
+	int liney = -Radius*std::cos(ang);
 
-	int w = int(0.2*Radius);
-	int h = int(0.1*Radius);
+	return Origin + QPoint{ linex, liney };
+}
 
-	NumericDisplay->setFixedSize(w, h);
-	NumericDisplay->move(Origin - QPoint{ w / 2 , h / 2 });
-} // void AttitudeDial::UpdateNumericDisplay()
+QPoint AttitudeDial::HandEndingCenteredNominal() const {
+	double rangeCtr = (Range[1] - Range[0]) / 2.0;
+	double ang = (CurrentAngle - rangeCtr) * 3.14 / 180.0;
+	int linex = -Radius*std::sin(ang);
+	int liney = Radius*std::cos(ang);
 
-void AttitudeDial::UpdateNumericFont() {
-	int pts = Radius / 20;
-	pts = (pts < 1) ? 1 : pts;
+	return Origin + QPoint{ linex, liney };
+}
 
-	NumericDisplayFont.setPointSize(pts);
-	NumericDisplay->setFont(NumericDisplayFont);
-} // void AttitudeDial::UpdateNumericDisplay()
+void AttitudeDial::SetRangeType(RangeType newRangeType) {
+	RangeTypeMode = newRangeType;
+	
+	switch (RangeTypeMode) {
+	case RangeType::LowestNominal:
+		RangeHandlerFunction = std::bind(&AttitudeDial::HandEndingLowestNominal, this);
+		break;
+	case RangeType::CenteredNominal:
+	default:
+		RangeHandlerFunction = std::bind(&AttitudeDial::HandEndingCenteredNominal, this);
+		break;
+	}
 
-void AttitudeDial::SetNumericDisplayState(bool enabled) {
-	NumericDisplayEnabled = enabled;
-	NumericDisplay->setVisible(enabled);
 	update();
-} // void AttitudeDial::UpdateNumericDisplay()
+}
 
 void AttitudeDial::PaintCircularBacking(QPainter* painter) {
 	QBrush fillBrush = painter->brush();
@@ -78,43 +72,41 @@ void AttitudeDial::PaintCircularBacking(QPainter* painter) {
 } // void AttitudeDial::PaintCircularBacking()
 
 void AttitudeDial::PaintTicks(QPainter* painter) {
-	for (int i = 0; i < 12; i++) {
-		QPoint st, ed;
+	for (int i = 0; i < 8; i++) {
 		QColor tickcolor;
-		const double ci = Radius*Cos30Degs[i];
-		const double si = Radius*Sin30Degs[i];
-		double ticker[2] = { 0.0, 1.0 };
+		std::array<double, 2> ticker = { 0.0, 1.0 };
+		std::array<double, 2> cossin;
 
 		switch (i) {
 		case 0:
-		case 3:
-		case 6:
-		case 9: // major
+		case 1:
+		case 2:
+		case 3: // major
 			ticker[0] = 0.85;
 			tickcolor = Palette.MajorTick;
+			cossin = MajorTicks[i];
 			break;
 		default: // minor
 			ticker[0] = 0.95;
 			tickcolor = Palette.MinorTick;
+			cossin = MinorTicks[i - 4];
 			break;
 		}
 
-		st = Origin + ticker[0] * QPoint{ int(ci), int(si) };
-		ed = Origin + ticker[1] * QPoint{ int(ci), int(si) };
-
+		double ci = Radius * cossin[0];
+		double si = Radius * cossin[1];
 		QPen pen = painter->pen();
 		pen.setColor(tickcolor);
 
+		QPoint st = Origin + ticker[0] * QPoint{ int(ci), int(si) };
+		QPoint ed = Origin + ticker[1] * QPoint{ int(ci), int(si) };
 		painter->setPen(pen);
 		painter->drawLine(st, ed);
 	}
 } // void AttitudeDial::PaintTicks()
 
 void AttitudeDial::PaintHand(QPainter* painter) {
-	double ang = CurrentAngle * 3.14 / 180.0;
-	int linex = Radius*std::sin(ang);
-	int liney = -Radius*std::cos(ang);
-	QPoint end = Origin + QPoint{ linex, liney };
+	QPoint end = (RangeHandlerFunction) ? RangeHandlerFunction(this) : Origin + QPoint{ 0, (int)Radius };
 
 	QPen pen = painter->pen();
 	pen.setColor(Palette.Hand);
@@ -147,10 +139,5 @@ void AttitudeDial::paintEvent(QPaintEvent* event) {
 	PaintTicks(&painter);
 	PaintHand(&painter);
 	PaintCap(&painter);
-
-	if (NumericDisplayEnabled) {
-		UpdateNumericDisplay();
-		UpdateNumericFont();
-	}
 }
 } // namespace VSCL
diff --git a/src/Widgets/Dial/AttitudeDial.hpp b/src/Widgets/Dial/Attitude.hpp
similarity index 51%
rename from src/Widgets/Dial/AttitudeDial.hpp
rename to src/Widgets/Dial/Attitude.hpp
index 3033ab2..4d81b13 100644
--- a/src/Widgets/Dial/AttitudeDial.hpp
+++ b/src/Widgets/Dial/Attitude.hpp
@@ -1,15 +1,16 @@
 #pragma once
 
+#include <cstdint>
 #include <array>
 #include <QtWidgets>
 
 namespace VSCL {
 struct AttitudeDialPalette {
 	QColor Primary = QColorConstants::White;
-	QColor Hand = QColorConstants::Black;
+	QColor Hand = QColorConstants::Red;
 	QColor Cap = QColorConstants::Black;
 	QColor MajorTick = QColorConstants::DarkGray;
-	QColor MinorTick = QColorConstants::DarkGray;
+	QColor MinorTick = QColorConstants::LightGray;
 };
 
 class AttitudeDial : public QWidget {
@@ -18,15 +19,18 @@ class AttitudeDial : public QWidget {
 
 public:
 	AttitudeDial(QWidget* parent);
-	AttitudeDial(QWidget* parent, bool enabled);
 
 	void SetDialAngle(double value);
-	void SetNumericDisplayState(bool enabled);
-
 	void SetPalette(AttitudeDialPalette& newPalette);
 	AttitudeDialPalette GetPalette() const;
 	const AttitudeDialPalette& GetPaletteView() const;
 
+	enum class RangeType : uint8_t {
+		CenteredNominal,
+		LowestNominal
+	};
+	void SetRangeType(RangeType newRangeType);
+
 	virtual void paintEvent(QPaintEvent* event) override;
 
 private:
@@ -37,28 +41,24 @@ class AttitudeDial : public QWidget {
 	void UpdateRadius();
 
 	AttitudeDialPalette Palette;
-
-	QFont NumericDisplayFont;
-	QLabel* NumericDisplay;
-	bool NumericDisplayEnabled = true;
-	void UpdateNumericFont();
-	void UpdateNumericDisplay();
+	std::array<double, 2> Range = { -180, 180 };
+	RangeType RangeTypeMode = RangeType::CenteredNominal;
+	QPoint HandEndingLowestNominal() const;
+	QPoint HandEndingCenteredNominal() const;
+	std::function<QPoint(const AttitudeDial&)> RangeHandlerFunction = nullptr;
 
 	void PaintCircularBacking(QPainter* painter);
 	void PaintTicks(QPainter* painter);
 	void PaintHand(QPainter* painter);
 	void PaintCap(QPainter* painter);
 
-	static constexpr std::array<double, 12> Cos30Degs = {
-		1.0, 0.8660254037844387, 0.5, 0.0,
-		-0.5, -0.8660254037844387, -1.0, -0.8660254037844387, 
-		-0.5, 0.0, 0.5, 0.8660254037844387 
-	};
-	static constexpr std::array<double, 12> Sin30Degs = {
-		0.0, 0.5, 0.8660254037844387, 1.0,
-		0.8660254037844387, 0.5, 0.0, -0.5,
-		-0.8660254037844387, -1.0, -0.8660254037844387, -0.5
-	};
+	static constexpr std::array<std::array<double, 2>, 4> MajorTicks = {{
+		{ 1.0, 0.0 }, { 0.0, 1.0 }, { -1.0, 0.0 }, { 0.0, -1.0 }
+	}};
 
+	static constexpr std::array<std::array<double, 2>, 4> MinorTicks = {{
+		{ 0.7071067811865475, 0.7071067811865475 }, { 0.7071067811865475, -0.7071067811865475 },
+		{ -0.7071067811865475, -0.7071067811865475 }, { -0.7071067811865475, 0.7071067811865475 } 
+	}};
 }; // class AttitudeDial
 } // namespace VSCL
diff --git a/src/Widgets/Dial/Composite.cpp b/src/Widgets/Dial/Composite.cpp
new file mode 100644
index 0000000..5e2760d
--- /dev/null
+++ b/src/Widgets/Dial/Composite.cpp
@@ -0,0 +1,63 @@
+#include "Composite.hpp"
+
+namespace VSCL {
+
+CompositeDial::CompositeDial(QWidget* parent) : QWidget(parent) {
+	// Widget setup goes top -> bottom level
+	
+	// Top-level
+	MajorOrganizer = new QGridLayout(this);
+	this->setLayout(MajorOrganizer);
+	this->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
+
+	MajorOrganizer->setAlignment(Qt::AlignHCenter);
+	MajorOrganizer->setAlignment(DialNameLabel, Qt::AlignHCenter | Qt::AlignTop);
+
+	DialNameLabel = new QLabel(this);
+	DialRateDuo = new QWidget(this);
+
+	DialNameLabel->setText("Dial");
+	DialNameLabel->setScaledContents(true);
+	DialNameLabel->setFont(DialNameFont);
+	DialNameLabel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
+
+	MajorOrganizer->addWidget(DialNameLabel, 0, 0, 1, 1);
+	MajorOrganizer->addWidget(DialRateDuo, 1, 0, 5, 1);
+
+	// Bottom-level
+	DuoOrganizer = new QGridLayout(DialRateDuo);
+	DialRateDuo->setLayout(DuoOrganizer);
+
+	Dial = new AttitudeDial(DialRateDuo);
+	NumericRateLabel = new RateLabel(DialRateDuo);
+
+	DuoOrganizer->addWidget(Dial, 0, 0);
+	DuoOrganizer->addWidget(NumericRateLabel, 0, 0);
+
+	QSizePolicy expandPolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
+	DuoOrganizer->setAlignment(NumericRateLabel, Qt::AlignHCenter | Qt::AlignVCenter);
+	DialRateDuo->setSizePolicy(expandPolicy);
+	Dial->setSizePolicy(expandPolicy);
+}
+
+CompositeDial::CompositeDial(const QString& title, QWidget* parent)
+	: CompositeDial(parent) {
+	DialNameLabel->setText(title);
+}
+
+void CompositeDial::resizeEvent(QResizeEvent* event) {
+	QWidget::resizeEvent(event);
+
+	DialNameFont.setPointSize(TitleAdjustment.AdjustPointSize(window()));
+	DialNameLabel->setFont(DialNameFont);
+}
+
+// Wrap accessors and settors of child widgets {{{
+void CompositeDial::SetDialTitle(const QString& title) { DialNameLabel->setText(title); }
+void CompositeDial::SetDialAngle(double value) { Dial->SetDialAngle(value); }
+void CompositeDial::DisplayRateFromArray(
+	const std::vector<double>& ts, const std::vector<double>& qtys) {
+		NumericRateLabel->DisplayRateFromArray(ts, qtys); }
+// }}}
+} // namespace VSCL
+// vim: foldmethod=marker
diff --git a/src/Widgets/Dial/Composite.hpp b/src/Widgets/Dial/Composite.hpp
new file mode 100644
index 0000000..ffb41d7
--- /dev/null
+++ b/src/Widgets/Dial/Composite.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <QWidget>
+#include <QLabel>
+
+#include "Dial/Attitude.hpp"
+#include "Displays/RateLabel.hpp"
+#include "Util/Sizing.hpp"
+
+namespace VSCL {
+
+/*
+ *	@brief The composite dial combines multiple elements together:
+ *	A base dial, title, and rate display.
+ */
+class CompositeDial : public QWidget {
+
+	Q_OBJECT;
+
+public:
+	CompositeDial(QWidget* parent);
+	CompositeDial(const QString& title, QWidget* parent);
+	virtual void resizeEvent(QResizeEvent* event) override;
+
+	void SetDialTitle(const QString& title);
+	void SetDialAngle(double value);
+	void DisplayRateFromArray(const std::vector<double>& ts, const std::vector<double>& qtys);
+
+private:
+	QGridLayout* MajorOrganizer;
+	QLabel* DialNameLabel;
+	QFont DialNameFont{ };
+	Util::FontAdjustment TitleAdjustment{ 16, false };
+
+	QGridLayout* DuoOrganizer;
+	QWidget* DialRateDuo;
+	AttitudeDial* Dial;
+	RateLabel* NumericRateLabel;
+
+}; // class CompositeDial
+} // namespace VSCL
diff --git a/src/Widgets/Displays/QuantitiesRatesRow.cpp b/src/Widgets/Displays/QuantitiesRatesRow.cpp
index eb4800c..db9b14e 100644
--- a/src/Widgets/Displays/QuantitiesRatesRow.cpp
+++ b/src/Widgets/Displays/QuantitiesRatesRow.cpp
@@ -23,11 +23,12 @@ QtyRateRow::QtyRateRow(const QString& title, QtyRateDisplay* parent) : QGroupBox
 }
 
 void QtyRateRow::resizeEvent(QResizeEvent* event) {
+	QGroupBox::resizeEvent(event);
 	AdjustFontSize();
 }
 
 void QtyRateRow::AdjustFontSize() {
-	int tpt = TitleFontAdjustment.AdjustPointSize(window());
+	unsigned int tpt = static_cast<unsigned int>(TitleFontAdjustment.AdjustPointSize(window()));
 	if (tpt <= TitleFontAdjustment.PointSizeAtMinimum) {
 		setTitle(tr(""));
 		TitleFont.setPointSize(1);
diff --git a/src/Widgets/Displays/RateLabel.cpp b/src/Widgets/Displays/RateLabel.cpp
new file mode 100644
index 0000000..fb5b0e8
--- /dev/null
+++ b/src/Widgets/Displays/RateLabel.cpp
@@ -0,0 +1,51 @@
+#include <cassert>
+#include <array>
+
+#include "RateLabel.hpp"
+#include "Util/FiniteDiff.hpp"
+
+namespace VSCL {
+RateLabel::RateLabel(QWidget* parent) : QLabel(parent) {
+	SetTextFrom(0.0);
+	setFrameStyle(QFrame::StyledPanel | QFrame::Plain);
+	setStyleSheet("background-color: white;"
+				  "color: black;"
+				  "font: bold;"
+				  "margin: 2%;"
+				  "border-style: outset;"
+				  "border-color: black;"
+				  "border-width: 1%;"
+				  "border-radius: 5%;"
+				  "padding: 1%;");
+
+	Font.setPointSize(FontAdjustment.PointSizeAtMinimum);
+	setFont(Font);
+}
+
+void RateLabel::resizeEvent(QResizeEvent* event) {
+	QLabel::resizeEvent(event);
+	Font.setPointSize(FontAdjustment.AdjustPointSize(window()));
+	setFont(Font);
+}
+
+void RateLabel::SetTextFrom(double num) {
+	setText(QString::number(num) + QuantityUnitString + TimeUnitString);
+}
+
+void RateLabel::SetRateFromArray(const std::vector<double>& ts, const std::vector<double>& qtys) {
+	size_t tsz = ts.size();
+	size_t qsz = qtys.size();
+
+	if (tsz < 3) { return; };
+	if (qsz < 3) { return; };
+
+	const std::array<double, 3> tst = { ts[tsz - 1], ts[tsz - 2], ts[tsz - 3] };
+	const std::array<double, 3> qst = { qtys[qsz - 1], qtys[qsz - 2], qtys[qsz - 3] };
+	Rate = Util::CenterFiniteDifference(tst, qst);
+}
+
+void RateLabel::DisplayRateFromArray(const std::vector<double>& ts, const std::vector<double>& qtys) {
+	SetRateFromArray(ts, qtys);
+	SetTextFrom(Rate);
+}
+} // namespace VSCL
diff --git a/src/Widgets/Displays/RateLabel.hpp b/src/Widgets/Displays/RateLabel.hpp
new file mode 100644
index 0000000..a322978
--- /dev/null
+++ b/src/Widgets/Displays/RateLabel.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <QLabel>
+#include "Util/Sizing.hpp"
+
+namespace VSCL {
+
+/*
+ *	A label that automatically computes and displays a finite difference on an attached array.
+ */
+class RateLabel : public QLabel {
+
+	Q_OBJECT;
+
+public:
+	RateLabel(QWidget* parent);
+	virtual void resizeEvent(QResizeEvent* event) override;
+
+	void SetTextFrom(double num);
+	void SetRateFromArray(const std::vector<double>& ts, const std::vector<double>& qtys);
+	void DisplayRateFromArray(const std::vector<double>& ts, const std::vector<double>& qtys);
+
+private:
+	double Rate = 0.0;
+	QString QuantityUnitString = "";
+	QString TimeUnitString = "/s";
+
+	Util::FontAdjustment FontAdjustment{ 10, false };
+	QFont Font{};
+
+}; // class RateLabel
+} // namespace VSCL
diff --git a/src/Windowing/DevWindow.cpp b/src/Windowing/DevWindow.cpp
index 5f10c8b..ba95777 100644
--- a/src/Windowing/DevWindow.cpp
+++ b/src/Windowing/DevWindow.cpp
@@ -3,7 +3,7 @@
 #include <QFileDialog>
 
 #include "DevWindow.hpp"
-#include "Dial/AttitudeDial.hpp"
+#include "Dial/Attitude.hpp"
 
 namespace VSCL {
 DevWindow::DevWindow() {
diff --git a/src/Windowing/WidgetsRecreation.cpp b/src/Windowing/WidgetsRecreation.cpp
index 4a8ef19..ac01013 100644
--- a/src/Windowing/WidgetsRecreation.cpp
+++ b/src/Windowing/WidgetsRecreation.cpp
@@ -54,12 +54,14 @@ Widgets::Widgets() {
 	ButtonFont = QFont();
 	SetAllButtonTextSize();
 
-	SetRoll(2);
+	SetRoll(-32);
 	SetPitch(5);
 	SetYaw(100);
 } // void Widgets::Widgets()
 
 void Widgets::resizeEvent(QResizeEvent* event) {
+	QMainWindow::resizeEvent(event);
+
 	SetGridColumnsMinimums();
 	SetGridRowsMinimums();
 	SetAllButtonTextSize();
@@ -122,13 +124,13 @@ void Widgets::SetupAttitudeDials() {
 	dialsPolicy.setVerticalPolicy(QSizePolicy::MinimumExpanding);
 	AttitudeDialRow->setSizePolicy(dialsPolicy);
 
-	RollDial = new AttitudeDial(AttitudeDialRow, false);
+	RollDial = new CompositeDial(QString("Roll"), AttitudeDialRow);
 	AttitudeDialOrganizer->addWidget(RollDial);
 
-	PitchDial = new AttitudeDial(AttitudeDialRow, false);
+	PitchDial = new CompositeDial(QString("Pitch"), AttitudeDialRow);
 	AttitudeDialOrganizer->addWidget(PitchDial);
 
-	YawDial = new AttitudeDial(AttitudeDialRow, false);
+	YawDial = new CompositeDial(QString("Yaw"), AttitudeDialRow);
 	AttitudeDialOrganizer->addWidget(YawDial);
 
 	Dials = { RollDial, PitchDial, YawDial };
@@ -246,7 +248,7 @@ void Widgets::SetupTimeHistoryPlotQChart() {
 	rollInfo.Color = Plot::StandardColor.at("Red");
 
 	Plot::SeriesInfo pitchInfo;
-	pitchInfo.Name = "Pit.hpp";
+	pitchInfo.Name = "Pitch";
 	pitchInfo.Color = Plot::StandardColor.at("Green");
 
 	Plot::SeriesInfo yawInfo;
@@ -267,7 +269,7 @@ void Widgets::SetupAttQtysRatesDisplay() {
 	RollQtyRate = new QtyRateRow(tr("Roll"), AttQtysRates);
 	RollQtyRate->SetQuantityUnits("°");
 	RollQtyRate->SetRateUnits("°/s");
-	PitchQtyRate = new QtyRateRow(tr("Pit.hpp"), AttQtysRates);
+	PitchQtyRate = new QtyRateRow(tr("Pitch"), AttQtysRates);
 	PitchQtyRate->SetQuantityUnits("°");
 	PitchQtyRate->SetRateUnits("°/s");
 	YawQtyRate = new QtyRateRow(tr("Yaw"), AttQtysRates);
diff --git a/src/Windowing/WidgetsRecreation.hpp b/src/Windowing/WidgetsRecreation.hpp
index 29c2683..49d2768 100644
--- a/src/Windowing/WidgetsRecreation.hpp
+++ b/src/Windowing/WidgetsRecreation.hpp
@@ -3,7 +3,7 @@
 #include <array>
 #include <QtWidgets>
 
-#include "Widgets/Dial/AttitudeDial.hpp"
+#include "Widgets/Dial/Composite.hpp"
 #include "Widgets/Displays/QuantitiesRatesDisplay.hpp"
 #include "Widgets/Displays/QuantitiesRatesRow.hpp"
 #include "Plotting/Container.hpp"
@@ -35,10 +35,10 @@ class Widgets : public QMainWindow {
 	QFrame* AttitudeDialRow;
 	QHBoxLayout* AttitudeDialOrganizer;
 
-	AttitudeDial* RollDial;
-	AttitudeDial* PitchDial;
-	AttitudeDial* YawDial;
-	std::array<AttitudeDial*, 3> Dials;
+	CompositeDial* RollDial;
+	CompositeDial* PitchDial;
+	CompositeDial* YawDial;
+	std::array<CompositeDial*, 3> Dials;
 	void SetupAttitudeDials();
 
 	Plot::EmbeddablePlot2D* Plot;