diff --git a/Makefile b/Makefile
index 911b025c..2d87c5a2 100644
--- a/Makefile
+++ b/Makefile
@@ -70,6 +70,7 @@ SRCS += \
   ./watch-library/simulator/watch/watch_slcd.c \
   ./watch-library/simulator/watch/watch_storage.c \
   ./watch-library/simulator/watch/watch_tcc.c \
+  ./watch-library/simulator/watch/watch_uart.c \
 
 else
 
@@ -87,6 +88,7 @@ SRCS += \
   ./watch-library/hardware/watch/watch_slcd.c \
   ./watch-library/hardware/watch/watch_storage.c \
   ./watch-library/hardware/watch/watch_tcc.c \
+  ./watch-library/hardware/watch/watch_uart.c \
   ./watch-library/hardware/watch/watch_usb_descriptors.c \
   ./watch-library/hardware/watch/watch_usb_cdc.c \
 
diff --git a/watch-library/hardware/watch/watch_uart.c b/watch-library/hardware/watch/watch_uart.c
index 3aee7e3d..a1518b99 100644
--- a/watch-library/hardware/watch/watch_uart.c
+++ b/watch-library/hardware/watch/watch_uart.c
@@ -1,7 +1,7 @@
 /*
  * MIT License
  *
- * Copyright (c) 2020 Joey Castillo
+ * Copyright (c) 2020-2024 Joey Castillo
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -23,96 +23,53 @@
  */
 
 #include "watch_uart.h"
+#include "uart.h"
+#include "usb.h"
 #include <string.h>
 
-struct usart_sync_descriptor USART_0;
-struct io_descriptor *uart_io;
+void watch_enable_uart(const uint16_t tx_pin, const uint16_t rx_pin, uint32_t baud) {
+    uart_rxpo_t rxpo = UART_RXPO_NONE;
 
-void watch_enable_uart(const uint8_t tx_pin, const uint8_t rx_pin, uint32_t baud) {
-    SERCOM_USART_CTRLA_Type ctrla;
-    SERCOM_USART_CTRLB_Type ctrlb;
-    ctrla.reg = SERCOM_USART_CTRLA_DORD | SERCOM_USART_CTRLA_MODE(1);
-    ctrlb.reg = SERCOM_USART_CTRLB_CHSIZE(0);
-
-    MCLK->APBCMASK.reg |= MCLK_APBCMASK_SERCOM3;
-    GCLK->PCHCTRL[SERCOM3_GCLK_ID_CORE].reg = GCLK_PCHCTRL_GEN(0) | GCLK_PCHCTRL_CHEN;
-
-    while (0 == (GCLK->PCHCTRL[SERCOM3_GCLK_ID_CORE].reg & GCLK_PCHCTRL_CHEN)) {
-        // wait
+    if (rx_pin == HAL_GPIO_A1_pin()) {
+        rxpo = UART_RXPO_3;
+        HAL_GPIO_A1_in();
+        HAL_GPIO_A1_pmuxen(HAL_GPIO_PMUX_SERCOM);
+    } else if (rx_pin == HAL_GPIO_A2_pin()) {
+        rxpo = UART_RXPO_0;
+        HAL_GPIO_A2_in();
+        HAL_GPIO_A2_pmuxen(HAL_GPIO_PMUX_SERCOM);
+    } else if (rx_pin == HAL_GPIO_A3_pin()) {
+        rxpo = UART_RXPO_1;
+        HAL_GPIO_A3_in();
+        HAL_GPIO_A3_pmuxen(HAL_GPIO_PMUX_SERCOM);
+    } else if (rx_pin == HAL_GPIO_A4_pin()) {
+        rxpo = UART_RXPO_2;
+        HAL_GPIO_A4_in();
+        HAL_GPIO_A4_pmuxen(HAL_GPIO_PMUX_SERCOM);
     }
 
-	usart_sync_init(&USART_0, SERCOM3, (void *)NULL);
-
-    SERCOM3->USART.CTRLA.reg &= ~SERCOM_USART_CTRLA_ENABLE;
-
-    switch (tx_pin) {
-        case A2:
-            gpio_set_pin_direction(tx_pin, GPIO_DIRECTION_OUT);
-            gpio_set_pin_function(tx_pin, PINMUX_PB02C_SERCOM3_PAD0);
-            ctrla.reg |= SERCOM_USART_CTRLA_TXPO(0);
-            ctrlb.reg |= SERCOM_USART_CTRLB_TXEN;
-            break;
-        case A4:
-            gpio_set_pin_direction(tx_pin, GPIO_DIRECTION_OUT);
-            gpio_set_pin_function(tx_pin, PINMUX_PB00C_SERCOM3_PAD2);
-            ctrla.reg |= SERCOM_USART_CTRLA_TXPO(1);
-            ctrlb.reg |= SERCOM_USART_CTRLB_TXEN;
-            break;
-        default:
-            break;
-    }
-
-    switch (rx_pin) {
-        case A1:
-            gpio_set_pin_direction(rx_pin, GPIO_DIRECTION_IN);
-            gpio_set_pin_function(rx_pin, PINMUX_PB01C_SERCOM3_PAD3);
-            ctrla.reg |= SERCOM_USART_CTRLA_RXPO(3);
-            ctrlb.reg |= SERCOM_USART_CTRLB_RXEN;
-            break;
-        case A2:
-            gpio_set_pin_direction(rx_pin, GPIO_DIRECTION_IN);
-            gpio_set_pin_function(rx_pin, PINMUX_PB02C_SERCOM3_PAD0);
-            ctrla.reg |= SERCOM_USART_CTRLA_RXPO(0);
-            ctrlb.reg |= SERCOM_USART_CTRLB_RXEN;
-            break;
-        case A3:
-            gpio_set_pin_direction(rx_pin, GPIO_DIRECTION_IN);
-            gpio_set_pin_function(rx_pin, PINMUX_PB03C_SERCOM3_PAD1);
-            ctrla.reg |= SERCOM_USART_CTRLA_RXPO(1);
-            ctrlb.reg |= SERCOM_USART_CTRLB_RXEN;
-            break;
-        case A4:
-            gpio_set_pin_direction(rx_pin, GPIO_DIRECTION_IN);
-            gpio_set_pin_function(rx_pin, PINMUX_PB00C_SERCOM3_PAD2);
-            ctrla.reg |= SERCOM_USART_CTRLA_RXPO(2);
-            ctrlb.reg |= SERCOM_USART_CTRLB_RXEN;
-            break;
-        default:
-            break;
-    }
-    SERCOM3->USART.CTRLA.reg = ctrla.reg;
-    SERCOM3->USART.CTRLB.reg = ctrlb.reg;
-
-    if (hri_usbdevice_get_CTRLA_ENABLE_bit(USB)) {
-        uint64_t br = 65536 - ((65536 * 16.0f * baud) / 8000000);
-        SERCOM3->USART.BAUD.reg = (uint16_t)br;
+    if (tx_pin == HAL_GPIO_A2_pin()) {
+        uart_init_instance(3, UART_TXPO_0, rxpo, baud);
+        HAL_GPIO_A2_pmuxen(HAL_GPIO_PMUX_SERCOM);
+    } else if (tx_pin == HAL_GPIO_A4_pin()) {
+        uart_init_instance(3, UART_TXPO_2, rxpo, baud);
+        HAL_GPIO_A4_pmuxen(HAL_GPIO_PMUX_SERCOM);
     } else {
-        uint64_t br = 65536 - ((65536 * 16.0f * baud) / 4000000);
-        SERCOM3->USART.BAUD.reg = (uint16_t)br;
+        uart_init_instance(3, UART_TXPO_NONE, rxpo, baud);
     }
 
-    SERCOM3->USART.CTRLA.reg |= SERCOM_USART_CTRLA_ENABLE;
-
-	usart_sync_enable(&USART_0);
-    usart_sync_get_io_descriptor(&USART_0, &uart_io);
+    uart_enable_instance(3);
 }
 
-void watch_uart_puts(char *s) {
-	io_write(uart_io, (uint8_t *)s, strlen(s));
+void watch_uart_puts(uint8_t *s) {
+    uart_write_instance(3, s, strlen((const char *)s));
 }
 
-char watch_uart_getc(void) {
-    uint8_t retval;
-    io_read(uart_io, &retval, 1);
-    return retval;
+size_t watch_uart_gets(uint8_t *data, size_t max_length) {
+    return uart_read_instance(3, data, max_length);
 }
+
+void irq_handler_sercom3(void);
+void irq_handler_sercom3(void) {
+    uart_irq_handler(3);
+}
\ No newline at end of file
diff --git a/watch-library/shared/watch/watch.h b/watch-library/shared/watch/watch.h
index 805686e1..e38ab9e0 100644
--- a/watch-library/shared/watch/watch.h
+++ b/watch-library/shared/watch/watch.h
@@ -69,7 +69,7 @@ typedef void (*watch_cb_t)(void);
 #include "watch_gpio.h"
 // #include "watch_i2c.h"
 // #include "watch_spi.h"
-// #include "watch_uart.h"
+#include "watch_uart.h"
 #include "watch_storage.h"
 #include "watch_deepsleep.h"
 
diff --git a/watch-library/shared/watch/watch_uart.h b/watch-library/shared/watch/watch_uart.h
index 3d7ee778..bcbcd4db 100644
--- a/watch-library/shared/watch/watch_uart.h
+++ b/watch-library/shared/watch/watch_uart.h
@@ -25,6 +25,7 @@
 #define _WATCH_UART_H_INCLUDED
 ////< @file watch_uart.h
 
+#include <stddef.h>
 #include "watch.h"
 
 /** @addtogroup uart UART
@@ -32,25 +33,26 @@
   **/
 /// @{
 
-/** @brief Initializes the debug UART.
+/** @brief Initializes the UART.
   * @param tx_pin The pin the watch will use to transmit, or 0 for a receive-only UART.
-  *               If specified, must be either A2 or A4.
+  *               If specified, must be either HAL_GPIO_A2_pin() or HAL_GPIO_A4_pin().
   * @param rx_pin The pin the watch will use to receive, or 0 for a transmit-only UART.
   *               If specified, must be A1, A2, A3 or A4 (pin A0 cannot receive UART data).
   * @param baud The baud rate for the UART. A typical value is 19200.
   */
-void watch_enable_uart(const uint8_t tx_pin, const uint8_t rx_pin, uint32_t baud);
+void watch_enable_uart(const uint16_t tx_pin, const uint16_t rx_pin, uint32_t baud);
 
 /** @brief Transmits a string of bytes on the UART's TX pin.
   * @param s A null-terminated string containing the bytes you wish to transmit.
   */
-void watch_uart_puts(char *s);
+void watch_uart_puts(uint8_t *s);
 
-/** @brief Receives a single byte from the UART's RX pin.
-  * @return the received byte.
-  * @note This method will block until a byte is received!
+/** @brief Returns a string of bytes received on the UART's RX pin.
+  * @param data A pointer to a buffer where the received bytes will be stored.
+  * @param max_length The maximum number of bytes to receive.
+  * @return The number of bytes actually received into the buffer.
   */
-char watch_uart_getc(void);
+size_t watch_uart_gets(uint8_t *data, size_t max_length);
 
 /// @}
 #endif
diff --git a/watch-library/simulator/watch/watch_uart.c b/watch-library/simulator/watch/watch_uart.c
index 80c6a812..f523cce2 100644
--- a/watch-library/simulator/watch/watch_uart.c
+++ b/watch-library/simulator/watch/watch_uart.c
@@ -23,23 +23,22 @@
  */
 
 #include "watch_uart.h"
-#include "peripheral_clk_config.h"
 
 static bool tx_enable = false;
 static bool rx_enable = false;
 
-void watch_enable_uart(const uint8_t tx_pin, const uint8_t rx_pin, uint32_t baud) {
+void watch_enable_uart(const uint16_t tx_pin, const uint16_t rx_pin, uint32_t baud) {
     tx_enable = !!tx_pin;
     rx_enable = !!rx_pin;
 }
 
-void watch_uart_puts(char *s) {
+void watch_uart_puts(uint8_t *s) {
 	if (tx_enable) {
         // TODO: hook up to UI
     }
 }
 
-char watch_uart_getc(void) {
+size_t watch_uart_gets(uint8_t *data, size_t max_length) {
 	if (rx_enable) {
         // TODO: hook up to UI
     }