diff --git a/wpilibc/Athena/include/Encoder.h b/wpilibc/Athena/include/Encoder.h
new file mode 100644
index 0000000..76bfaf9
--- /dev/null
+++ b/wpilibc/Athena/include/Encoder.h
@@ -0,0 +1,113 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) FIRST 2008. All Rights Reserved.
+ */
+/* Open Source Software - may be modified and shared by FRC teams. The code   */
+/* must be accompanied by the FIRST BSD license file in $(WIND_BASE)/WPILib.  */
+/*----------------------------------------------------------------------------*/
+#pragma once
+
+#include "HAL/HAL.hpp"
+#include "CounterBase.h"
+#include "SensorBase.h"
+#include "Counter.h"
+#include "PIDSource.h"
+#include "LiveWindow/LiveWindowSendable.h"
+
+#include <memory>
+
+class DigitalSource;
+class DigitalGlitchFilter;
+
+/**
+ * Class to read quad encoders.
+ * Quadrature encoders are devices that count shaft rotation and can sense
+ * direction. The output of
+ * the QuadEncoder class is an integer that can count either up or down, and can
+ * go negative for
+ * reverse direction counting. When creating QuadEncoders, a direction is
+ * supplied that changes the
+ * sense of the output to make code more readable if the encoder is mounted such
+ * that forward movement
+ * generates negative values. Quadrature encoders have two digital outputs, an A
+ * Channel and a B Channel
+ * that are out of phase with each other to allow the FPGA to do direction
+ * sensing.
+ *
+ * All encoders will immediately start counting - Reset() them if you need them
+ * to be zeroed before use.
+ */
+class Encoder : public SensorBase,
+                public CounterBase,
+                public PIDSource,
+                public LiveWindowSendable {
+ public:
+  enum IndexingType {
+    kResetWhileHigh,
+    kResetWhileLow,
+    kResetOnFallingEdge,
+    kResetOnRisingEdge
+  };
+
+  Encoder(uint32_t aChannel, uint32_t bChannel, bool reverseDirection = false,
+          EncodingType encodingType = k4X);
+  Encoder(std::shared_ptr<DigitalSource> aSource,
+          std::shared_ptr<DigitalSource> bSource,
+          bool reverseDirection = false, EncodingType encodingType = k4X);
+  Encoder(DigitalSource *aSource, DigitalSource *bSource,
+          bool reverseDirection = false, EncodingType encodingType = k4X);
+  Encoder(DigitalSource &aSource, DigitalSource &bSource,
+          bool reverseDirection = false, EncodingType encodingType = k4X);
+  virtual ~Encoder();
+
+  // CounterBase interface
+  int32_t Get() const override;
+  int32_t GetRaw() const;
+  int32_t GetEncodingScale() const;
+  void Reset() override;
+  double GetPeriod() const override;
+  void SetMaxPeriod(double maxPeriod) override;
+  bool GetStopped() const override;
+  bool GetDirection() const override;
+
+  double GetDistance() const;
+  double GetRate() const;
+  void SetMinRate(double minRate);
+  void SetDistancePerPulse(double distancePerPulse);
+  void SetReverseDirection(bool reverseDirection);
+  void SetSamplesToAverage(int samplesToAverage);
+  int GetSamplesToAverage() const;
+  double PIDGet() override;
+
+  void SetIndexSource(uint32_t channel, IndexingType type = kResetOnRisingEdge);
+  DEPRECATED("Use pass-by-reference instead.")
+  void SetIndexSource(DigitalSource *source,
+                      IndexingType type = kResetOnRisingEdge);
+  void SetIndexSource(const DigitalSource &source,
+                      IndexingType type = kResetOnRisingEdge);
+
+  void UpdateTable() override;
+  void StartLiveWindowMode() override;
+  void StopLiveWindowMode() override;
+  std::string GetSmartDashboardType() const override;
+  void InitTable(std::shared_ptr<ITable> subTable) override;
+  std::shared_ptr<ITable> GetTable() const override;
+
+  int32_t GetFPGAIndex() const { return m_index; }
+
+ private:
+  void InitEncoder(bool _reverseDirection, EncodingType encodingType);
+  double DecodingScaleFactor() const;
+
+  std::shared_ptr<DigitalSource> m_aSource; // the A phase of the quad encoder
+  std::shared_ptr<DigitalSource> m_bSource; // the B phase of the quad encoder
+  void *m_encoder = nullptr;
+  int32_t m_index = 0;             // The encoder's FPGA index.
+  double m_distancePerPulse = 1.0; // distance of travel for each encoder tick
+  std::unique_ptr<Counter> m_counter =
+      nullptr;                     // Counter object for 1x and 2x encoding
+  EncodingType m_encodingType;     // Encoding type
+  int32_t m_encodingScale;         // 1x, 2x, or 4x, per the encodingType
+
+  std::shared_ptr<ITable> m_table;
+  friend class DigitalGlitchFilter;
+};