Features of UDP

UDP (User Datagram Protocol) is defined by what it leaves out. It's a transport layer protocol — its job is to carry data from a program on one machine to a program on another — but it does that job with the bare minimum of machinery. A handful of features flow from that one design choice: stay simple, stay fast.

Here are the traits that define UDP. We'll unpack the most important ones right after this overview.

Connectionless means UDP never establishes a connection before sending. There's no opening handshake — no exchange of setup messages to confirm both sides are ready. The sender just addresses a datagram and sends it. This saves time (nothing happens before the first byte goes out) but it also means UDP has no memory of who it's talking to — every datagram stands entirely on its own.

UDP hands each datagram to the network and hopes for the best. It does not number datagrams, does not wait for an acknowledgement, and does not resend anything that goes missing. So three things can happen without UDP ever noticing: a datagram can be lost, datagrams can arrive out of order, or a datagram can be duplicated. "Unreliable" is just the technical name for "makes no delivery guarantee" — it doesn't mean UDP is flaky, only that catching these problems is left to the application if it cares.

UDP is message-oriented, which means it keeps the boundaries of each message intact. If your program sends one 100-byte message and then one 50-byte message, the receiver gets them as two separate datagrams — one of 100 bytes and one of 50. Compare that with TCP, which is a byte stream: TCP treats everything you send as one continuous flow of bytes, so the receiver might read the two messages glued together or split apart, and the app has to figure out where one ends and the next begins. With UDP, one send equals one receive.

Two safety brakes that TCP has, UDP leaves out. Flow control stops a fast sender from overwhelming a slow receiver. Congestion control backs off when the network in the middle is getting overloaded. UDP does neither — it simply sends at whatever rate the application asks. That keeps UDP simple and fast, but it also means a careless UDP app can flood a slow receiver or make network congestion worse, so well-behaved UDP apps pace themselves.