diff --git a/frc971/can_logger/BUILD b/frc971/can_logger/BUILD
new file mode 100644
index 0000000..a3b002a
--- /dev/null
+++ b/frc971/can_logger/BUILD
@@ -0,0 +1,39 @@
+load("@com_github_google_flatbuffers//:build_defs.bzl", "flatbuffer_cc_library")
+
+cc_binary(
+    name = "can_logger",
+    srcs = [
+        "can_logger_main.cc",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":can_logger_lib",
+        "//aos:init",
+        "//aos/events:shm_event_loop",
+        "//aos/time",
+        "@com_github_google_glog//:glog",
+    ],
+)
+
+cc_library(
+    name = "can_logger_lib",
+    srcs = [
+        "can_logger.cc",
+        "can_logger.h",
+    ],
+    deps = [
+        ":can_logging_fbs",
+        "//aos/events:event_loop",
+        "//aos/scoped:scoped_fd",
+        "@com_github_google_glog//:glog",
+    ],
+)
+
+flatbuffer_cc_library(
+    name = "can_logging_fbs",
+    srcs = [
+        "can_logging.fbs",
+    ],
+    gen_reflections = 1,
+    visibility = ["//visibility:public"],
+)
diff --git a/frc971/can_logger/can_logger.cc b/frc971/can_logger/can_logger.cc
new file mode 100644
index 0000000..6b4258a
--- /dev/null
+++ b/frc971/can_logger/can_logger.cc
@@ -0,0 +1,88 @@
+#include "frc971/can_logger/can_logger.h"
+
+namespace frc971 {
+namespace can_logger {
+
+CanLogger::CanLogger(aos::EventLoop *event_loop,
+                     std::string_view interface_name)
+    : fd_(socket(PF_CAN, SOCK_RAW | SOCK_NONBLOCK, CAN_RAW)),
+      frames_sender_(event_loop->MakeSender<CanFrame>("/can")) {
+  struct ifreq ifr;
+  strcpy(ifr.ifr_name, interface_name.data());
+  PCHECK(ioctl(fd_.get(), SIOCGIFINDEX, &ifr) == 0)
+      << "Failed to get index for interface " << interface_name;
+
+  int enable_canfd = true;
+  PCHECK(setsockopt(fd_.get(), SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &enable_canfd,
+                    sizeof(enable_canfd)) == 0)
+      << "Failed to enable CAN FD";
+
+  struct sockaddr_can addr;
+  addr.can_family = AF_CAN;
+  addr.can_ifindex = ifr.ifr_ifindex;
+
+  PCHECK(bind(fd_.get(), reinterpret_cast<struct sockaddr *>(&addr),
+              sizeof(addr)) == 0)
+      << "Failed to bind socket to interface " << interface_name;
+
+  int recieve_buffer_size;
+  socklen_t opt_size = sizeof(recieve_buffer_size);
+  PCHECK(getsockopt(fd_.get(), SOL_SOCKET, SO_RCVBUF, &recieve_buffer_size,
+                    &opt_size) == 0);
+  CHECK_EQ(opt_size, sizeof(recieve_buffer_size));
+  VLOG(0) << "CAN recieve bufffer is " << recieve_buffer_size << " bytes large";
+
+  aos::TimerHandler *timer_handler = event_loop->AddTimer([this]() { Poll(); });
+  timer_handler->set_name("CAN logging Loop");
+  timer_handler->Setup(event_loop->monotonic_now(), kPollPeriod);
+}
+
+void CanLogger::Poll() {
+  VLOG(2) << "Polling";
+  int frames_read = 0;
+  while (ReadFrame()) {
+    frames_read++;
+  }
+  VLOG(1) << "Read " << frames_read << " frames to end of buffer";
+}
+
+bool CanLogger::ReadFrame() {
+  errno = 0;
+  struct canfd_frame frame;
+  ssize_t bytes_read = read(fd_.get(), &frame, sizeof(struct canfd_frame));
+
+  if (bytes_read < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
+    // There are no more frames sitting in the recieve buffer.
+    return false;
+  }
+
+  VLOG(2) << "Read " << bytes_read << " bytes";
+  PCHECK(bytes_read > 0);
+  PCHECK(bytes_read == static_cast<ssize_t>(CAN_MTU) ||
+         bytes_read == static_cast<ssize_t>(CANFD_MTU))
+      << "Incomplete can frame";
+
+  struct timeval tv;
+  PCHECK(ioctl(fd_.get(), SIOCGSTAMP, &tv) == 0)
+      << "Failed to get timestamp of CAN frame";
+
+  aos::Sender<CanFrame>::Builder builder = frames_sender_.MakeBuilder();
+
+  auto frame_data = builder.fbb()->CreateVector<uint8_t>(frame.data, frame.len);
+
+  CanFrame::Builder can_frame_builder = builder.MakeBuilder<CanFrame>();
+  can_frame_builder.add_can_id(frame.can_id);
+  can_frame_builder.add_data(frame_data);
+  can_frame_builder.add_monotonic_timestamp_ns(
+      static_cast<std::chrono::nanoseconds>(
+          std::chrono::seconds(tv.tv_sec) +
+          std::chrono::microseconds(tv.tv_usec))
+          .count());
+
+  builder.CheckOk(builder.Send(can_frame_builder.Finish()));
+
+  return true;
+}
+
+}  // namespace can_logger
+}  // namespace frc971
diff --git a/frc971/can_logger/can_logger.h b/frc971/can_logger/can_logger.h
new file mode 100644
index 0000000..cf37841
--- /dev/null
+++ b/frc971/can_logger/can_logger.h
@@ -0,0 +1,50 @@
+#ifndef FRC971_CAN_LOGGER_CAN_LOGGER_H_
+#define FRC971_CAN_LOGGER_CAN_LOGGER_H_
+
+#include <linux/can.h>
+#include <linux/can/raw.h>
+#include <linux/sockios.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+
+#include <chrono>
+
+#include "aos/events/event_loop.h"
+#include "aos/realtime.h"
+#include "aos/scoped/scoped_fd.h"
+#include "frc971/can_logger/can_logging_generated.h"
+
+namespace frc971 {
+namespace can_logger {
+
+// This class listens to all the traffic on a SocketCAN interface and sends it
+// on the aos event loop so it can be logged with the aos logging
+// infrastructure.
+class CanLogger {
+ public:
+  static constexpr std::chrono::milliseconds kPollPeriod =
+      std::chrono::milliseconds(100);
+
+  CanLogger(aos::EventLoop *event_loop,
+            std::string_view interface_name = "can0");
+
+  CanLogger(const CanLogger &) = delete;
+  CanLogger &operator=(const CanLogger &) = delete;
+
+ private:
+  void Poll();
+
+  // Read a CAN frame from the socket and send it on the event loop
+  // Returns true if successful and false if the recieve buffer is empty.
+  bool ReadFrame();
+
+  aos::ScopedFD fd_;
+  aos::Sender<CanFrame> frames_sender_;
+};
+
+}  // namespace can_logger
+}  // namespace frc971
+
+#endif  // FRC971_CAN_LOGGER_CAN_LOGGER_H_
diff --git a/frc971/can_logger/can_logger_main.cc b/frc971/can_logger/can_logger_main.cc
new file mode 100644
index 0000000..42c7162
--- /dev/null
+++ b/frc971/can_logger/can_logger_main.cc
@@ -0,0 +1,18 @@
+#include "aos/events/shm_event_loop.h"
+#include "aos/init.h"
+#include "frc971/can_logger/can_logger.h"
+
+int main(int argc, char **argv) {
+  ::aos::InitGoogle(&argc, &argv);
+
+  aos::FlatbufferDetachedBuffer<aos::Configuration> config =
+      aos::configuration::ReadConfig("aos_config.json");
+
+  ::aos::ShmEventLoop event_loop(&config.message());
+
+  frc971::can_logger::CanLogger can_logger(&event_loop, "can0");
+
+  event_loop.Run();
+
+  return 0;
+}
diff --git a/frc971/can_logger/can_logging.fbs b/frc971/can_logger/can_logging.fbs
new file mode 100644
index 0000000..d6ec8b9
--- /dev/null
+++ b/frc971/can_logger/can_logging.fbs
@@ -0,0 +1,13 @@
+namespace frc971.can_logger;
+
+// A message to represent a single CAN or CAN FD frame.
+table CanFrame {
+  // CAN id + flags
+  can_id:uint32 (id: 0);
+  // The body of the CAN frame up to 64 bytes long.
+  data:[ubyte] (id: 1);
+  // The hardware timestamp of when the frame came in
+  monotonic_timestamp_ns:uint64 (id: 2);
+}
+
+root_type CanFrame;