class UDPSocket


A User Datagram Protocol socket. UDP runs on top of the Internet Protocol (IP) and was developed for applications that do not require reliability, acknowledgement, or flow control features at the transport layer. This simple protocol provides transport layer addressing in the form of UDP ports and an optional checksum capability.

UDP is a very simple protocol. Messages, so called datagrams, are sent to other hosts on an IP network without the need to set up special transmission channels or data paths beforehand. The UDP socket only needs to be opened for communication. It listens for incoming messages and sends outgoing messages on request.

This implementation supports both IPv4 and IPv6 addresses. For IPv4 addresses you need use Socket::Family::INET family (used by default). And Socket::Family::INET6 for IPv6 addresses accordingly.

Usage example:

require "socket"

# Create server
server =
server.bind "localhost", 1234

# Create client and connect to server
client =
client.connect "localhost", 1234

client << "message" # send message to server      # => "message"

# Close client and server

Defined in:


Class Method Summary

Instance Method Summary

Instance methods inherited from class IPSocket

addr addr, peeraddr peeraddr

Instance methods inherited from class Socket

close_read close_read, close_write close_write, getsockopt(optname, optval, level = LibC::SOL_SOCKET) getsockopt, inspect(io) inspect, keepalive=(val : Bool) keepalive=, keepalive? keepalive?, linger linger, linger=(val : Int | Nil) linger=, recv_buffer_size recv_buffer_size, recv_buffer_size=(val : Int32) recv_buffer_size=, reuse_address=(val : Bool) reuse_address=, reuse_address? reuse_address?, send_buffer_size send_buffer_size, send_buffer_size=(val : Int32) send_buffer_size=, setsockopt(optname, optval, level = LibC::SOL_SOCKET) setsockopt

Class methods inherited from class Socket

inet_ntop(sa : LibC::SockAddrIn)
inet_ntop(sa : LibC::SockAddrIn6)
, new(fd, blocking = false) new

Instance methods inherited from class IO::FileDescriptor

blocking blocking, blocking=(value) blocking=, close_on_exec=(arg : Bool) close_on_exec=, close_on_exec? close_on_exec?, closed? closed?, fcntl(cmd, arg = 0) fcntl, fd fd, finalize finalize, pos pos, pos=(value) pos=, read_timed_out read_timed_out, read_timed_out=(read_timed_out) read_timed_out=, read_timeout=(read_timeout : Number)
read_timeout=(read_timeout : Time::Span)
read_timeout=(read_timeout : Nil)
, reopen(other : IO::FileDescriptor) reopen, seek(offset, whence = Seek::Set : Seek) seek, stat stat, tell tell, to_fd_io to_fd_io, tty? tty?, write_timed_out write_timed_out, write_timed_out=(write_timed_out) write_timed_out=, write_timeout=(write_timeout : Number)
write_timeout=(write_timeout : Time::Span)
write_timeout=(write_timeout : Nil)

Class methods inherited from class IO::FileDescriptor

fcntl(fd, cmd, arg = 0) fcntl, new(fd, blocking = false, edge_triggerable = false) new

Instance methods inherited from module IO::Buffered

close close, flush flush, flush_on_newline=(flush_on_newline) flush_on_newline=, flush_on_newline? flush_on_newline?, read(slice : Slice(UInt8)) read, rewind rewind, sync=(sync) sync=, sync? sync?, unbuffered_close unbuffered_close, unbuffered_flush unbuffered_flush, unbuffered_read(slice : Slice(UInt8)) unbuffered_read, unbuffered_rewind unbuffered_rewind, unbuffered_write(slice : Slice(UInt8)) unbuffered_write, write(slice : Slice(UInt8)) write

Instance methods inherited from module IO

<<(obj) : self <<, close close, cooked(&block) cooked, cooked! cooked!, each_byte
, each_char(&block)
, each_line(*args, &block)
, flush flush, gets(limit : Int) : String | Nil
gets(delimiter : Char, limit : Int) : String | Nil
gets(delimiter : Char) : String | Nil
gets : String | Nil
gets(delimiter : String) : String | Nil
, gets_to_end : String gets_to_end, print(*objects : _) : Nil
print(obj) : Nil
, printf(format_string, args : Array | Tuple) : Nil
printf(format_string, *args) : Nil
, puts : Nil
puts(*objects : _) : Nil
puts(string : String) : Nil
puts(obj) : Nil
, raw(&block) raw, raw! raw!, read(slice : Slice(UInt8)) read, read_byte : UInt8 | Nil read_byte, read_bytes(type, format = IO::ByteFormat::SystemEndian : IO::ByteFormat) read_bytes, read_char : Char | Nil read_char, read_fully(slice : Slice(UInt8)) read_fully, read_line(*args) : String | Nil read_line, read_nonblock(size) read_nonblock, skip(bytes_count : Int) : Nil skip, tty? : Bool tty?, write(slice : Slice(UInt8)) : Nil write, write_byte(byte : UInt8) write_byte, write_bytes(object, format = IO::ByteFormat::SystemEndian : IO::ByteFormat) write_bytes

Class methods inherited from module IO

copy(src, dst) copy, pipe(read_blocking = false, write_blocking = false, &block)
pipe(read_blocking = false, write_blocking = false)
, select(read_ios, write_ios, error_ios, timeout_sec : LibC::TimeT | Int | Float | Nil)
select(read_ios, write_ios = nil, error_ios = nil)

Instance methods inherited from module JSON::Builder

json_array(&block) json_array, json_object(&block) json_object

Instance methods inherited from class Reference

! !, ==(other)
==(other : self)
, hash hash, inspect(io : IO) : Nil inspect, nil? nil?, object_id object_id, same?(other : Nil)
same?(other : Reference)
, to_s(io : IO) : Nil to_s

Instance methods inherited from class Object

! !, !=(other) !=, !~(other) !~, ==(other) ==, ===(other) ===, =~(other) =~, class class, clone clone, crystal_type_id crystal_type_id, dup dup, hash hash, inspect
inspect(io : IO)
, itself itself, not_nil! not_nil!, tap(&block) tap, to_json to_json, to_pretty_json(io : IO)
, to_s
to_s(io : IO)
, to_yaml(io : IO)
, try(&block) try

Class methods inherited from class Object

==(other : Class) ==, ===(other) ===, cast(other) : self cast, from_json(string_or_io) from_json, from_yaml(string : String) from_yaml, hash hash, inspect(io) inspect, name : String name, to_s(io) to_s

Class Method Detail

def = Socket::Family::INET : Socket::Family) #

[View source]

Instance Method Detail

def bind(host, port, dns_timeout = nil) #

Creates a UDP socket from the given address.

server =
server.bind "localhost", 1234

[View source]
def connect(host, port, dns_timeout = nil, connect_timeout = nil) #

Attempts to connect the socket to a remote address and port for this socket.

client =
client.connect "localhost", 1234

[View source]