The short answer
Asynchronous means not happening at the same time or not coordinated by a shared timing signal. The word comes from Greek roots meaning “not with time”. Things that are asynchronous proceed independently, and each side handles events when they arrive rather than in lockstep with the other.
The opposite, synchronous, means coordinated in time: happening together, or driven by a common clock or schedule.
The exact meaning depends on context:
- Everyday communication: you send a message and the other person replies later.
- Serial communication: devices exchange data without a shared clock wire.
- Digital hardware: a signal can change at any moment, not just on a clock edge.
- Programming: a task starts and the program carries on without waiting for it to finish.
Asynchronous in everyday use
Email, text messages and forum posts are asynchronous communication: the sender and receiver don’t need to be present at the same time. A phone call or video meeting is synchronous, with both people taking part live. Asynchronous learning means coursework you complete on your own schedule, such as recorded lectures with deadlines, rather than live classes at fixed times.
Asynchronous communication in electronics
In embedded systems, “asynchronous” most often describes a serial link that has no shared clock signal between sender and receiver.
How asynchronous serial (UART) stays in step without a clock
A UART (universal asynchronous receiver-transmitter) is the classic example. The sender and receiver each use their own clock, so they have to agree on timing in advance and resynchronize as data arrives:
- Agree on a baud rate. Both sides are set to the same bit rate, such as 9600 or 115200 bits per second, and the same format, such as 8 data bits, no parity, 1 stop bit (“8N1”).
- Idle high. When nothing is being sent, the line sits at its idle (high) level.
- Start bit. The sender pulls the line low for one bit-time. That falling edge tells the receiver a character is beginning and lets it line up its timing.
- Data bits. The receiver samples each bit near the middle of its expected bit-time. Many UARTs oversample, for example 16 times per bit, to find the middle reliably.
- Stop bit. The line returns high for at least one bit-time, marking the end of the character and giving the receiver a gap before the next start bit.
Because the receiver re-aligns on every start bit, small differences between the two clocks don’t add up across a long message. They only need to stay close enough over one character. As a rule of thumb, the combined mismatch needs to stay within a few percent, which is why baud-rate mismatches show up as garbage characters.
Synchronous transmission for comparison
In synchronous communication, a clock signal travels with the data, either on its own wire or embedded in the data signal. The receiver samples each bit on a clock edge, so no baud rate agreement is needed and there’s no start or stop bit overhead per character. SPI and I2C are synchronous: the controller drives a clock line, and data is valid relative to its edges.
In short: synchronous links send timing alongside the data, while asynchronous links rely on both sides keeping time independently and resynchronizing on signal edges. Our embedded communication protocols guide compares UART, SPI, I2C and CAN in detail.
Other asynchronous protocols
- RS-232 and RS-485 carry UART-style asynchronous data over longer cables using different electrical signalling.
- CAN has no separate clock wire. Nodes resynchronize on edges in the data stream, so it’s usually described as asynchronous in this sense, though bit timing is tightly specified.
- 1-Wire is timed by pulses from the controller rather than a continuous clock.
Asynchronous signals in digital hardware
Asynchronous inputs and synchronizers
Inside a microcontroller or FPGA, most logic is synchronous: it changes state only on clock edges. Signals from the outside world, such as a button press, a sensor’s “data ready” line or a signal from another clock domain, are asynchronous: they can change at any instant, including right at a clock edge.
When a flip-flop samples a signal that’s changing at the wrong moment, it can briefly enter an undefined state called metastability. Hardware designers guard against this with synchronizers, typically two flip-flops in a row, before the signal is used. Microcontroller GPIO and peripheral inputs normally include this internally, so firmware developers rarely deal with it directly. It matters a lot to FPGA designers.
Asynchronous reset
Datasheets often mention asynchronous reset: a reset signal that takes effect immediately, without waiting for a clock edge. A synchronous reset acts only on the next clock edge. Microcontroller reset pins are typically asynchronous in effect, so pulling the pin low resets the chip whether or not its clock is running.
Asynchronous programming on microcontrollers
Blocking vs non-blocking code
A blocking (synchronous) call waits until its work is done before returning. For example, a function that sends 100 bytes over UART and returns only after the last byte leaves. During that time, the CPU can’t do anything else.
A non-blocking (asynchronous) call starts the work and returns straight away. The hardware carries on in the background, and the program is told later when it’s finished. Meanwhile, the CPU can update a display, read sensors or go to sleep to save power.
The familiar Arduino delay() function is blocking. Rewriting a loop to check elapsed time with millis() instead is a simple step toward non-blocking code.
Interrupts, DMA and callbacks
Microcontrollers support asynchronous work in hardware:
- Interrupts let a peripheral signal the CPU the moment something happens, such as a byte arriving, a timer expiring or a pin changing. The CPU pauses its current work, runs an interrupt service routine (ISR), then resumes.
- DMA (direct memory access) moves data between peripherals and memory without the CPU copying each byte, then raises an interrupt when the transfer completes.
- Callbacks are functions you register with a driver to be called when an operation finishes. Many vendor HAL libraries offer interrupt- or DMA-based versions of transmit and receive functions with completion callbacks.
An RTOS adds another layer: a task can wait on a queue or semaphore while other tasks run, and the waiting task wakes when an interrupt delivers the data.
async/await on embedded
Some languages offer async/await syntax that lets asynchronous code read like straight-line code. In embedded Rust, for example, frameworks such as Embassy use async/await to run many concurrent tasks on a single core without a traditional RTOS. MicroPython offers asyncio on supported boards. The underlying idea is the same: start an operation, yield until it completes, let something else run in the meantime.
The catch: shared data and race conditions
Because asynchronous events can arrive at any time, code that shares data between an ISR and the main program needs care:
- Mark variables shared with an ISR as
volatilein C or C++ so the compiler re-reads them rather than caching a stale value. - Protect multi-byte or read-modify-write accesses, for example by briefly disabling interrupts or using atomic operations, so an interrupt can’t land halfway through an update.
- Keep ISRs short: record the event or move the data, then let the main code or a task do the heavy work.
Asynchronous designs are powerful but harder to debug than step-by-step code, so it pays to keep the shared state small and well defined.
Synchronous vs asynchronous at a glance
| Context | Synchronous | Asynchronous |
|---|---|---|
| Everyday communication | Live call or meeting | Email, messages, forums |
| Serial communication | Shared clock (SPI, I2C) | No shared clock; agreed baud rate and start/stop bits (UART) |
| Digital logic | Changes on clock edges | Can change at any time; needs synchronizing |
| Reset | Takes effect on the next clock edge | Takes effect immediately |
| Programming | Blocking: wait until done | Non-blocking: continue and get notified later |
Across every context, the core idea is the same: asynchronous activities aren’t locked to a common clock or schedule, so each side has to deal with events whenever they arrive. To see where communication links and interrupts fit into a complete device, see our embedded system architecture guide.