A UART, or Universal Asynchronous Receiver/Transmitter, is the circuit that connects a processor’s parallel world of bytes to the serial world of a single wire carrying one bit at a time. On the transmit side it takes a byte and shifts it out bit by bit; on the receive side it watches an incoming line and reassembles the bits back into a byte. The word asynchronous is the key: unlike SPI or I2C, a UART link carries no separate clock signal, so the two ends must independently agree in advance on how fast bits arrive.
That agreed speed is the baud rate. Both ends are configured to the same rate, such as 9600 or 115200 bits per second, and the receiver uses its own internal clock to sample the line at the expected moments. To stay aligned, every byte is wrapped in a frame. The line idles high; a low start bit announces that a byte is beginning and gives the receiver an edge to synchronize on; then come the data bits, optionally a parity bit for error checking; and finally one or more stop bits that return the line to idle and separate one byte from the next. This start/stop framing is what lets two devices communicate reliably with no shared clock.
The Raspberry Pi’s BCM2835 ARM Peripherals datasheet documents two UART implementations on the chip, a full PL011 UART and a simpler mini UART, and its register descriptions make the abstract frame concrete. The datasheet shows the baud-rate divisor registers that set the bit timing, the line-control bits that choose data length, parity, and stop bits, and the transmit and receive FIFOs that buffer bytes so software does not have to service every single character the instant it arrives.
A UART defines only the logic-level serial protocol, the framing and timing of bits at the chip’s own voltage. Turning that into an interface that can run between separate pieces of equipment historically meant pairing it with a line standard, most famously RS-232, which specifies different voltage levels and connectors for the same start/stop byte stream. This is why a UART and RS-232 are so often spoken of together even though they are different layers: the UART makes the bits, and RS-232 carries them over a cable.
The UART’s reach in computing history is enormous. It connected the glass terminals and teletypewriters that gave Unix its tty devices, drove the modems that carried early online services and bulletin boards, and remains, decades later, the humble serial console that engineers attach to a misbehaving server or embedded board to watch boot messages and log in when nothing else works. Its endurance comes from needing just one wire per direction and a shared baud rate, an arrangement simple enough to implement on the smallest hardware.