@@ -38,8 +38,11 @@ add_library(takt4_core STATIC
   engine/control.hpp
   engine/live_tracker.cpp
   engine/live_tracker.hpp
+  control/osc_parse.cpp
+  control/osc_parse.hpp
   dsp/real_fft.cpp
   dsp/real_fft.hpp
+  net/udp.hpp
   features/dimensions.hpp
   features/feature_extractor.cpp
   features/feature_extractor.hpp
 
@@ -0,0 +1,174 @@
+#include "core/control/osc_parse.hpp"
+
+#include <bit>
+#include <cstring>
+
+namespace takt4::control {
+namespace {
+
+/// OSC pads every part to a multiple of four bytes *after* its terminator, so a
+/// four-character address takes eight.
+constexpr std::size_t kAlign = 4;
+
+std::size_t padded(std::size_t length) noexcept {
+    return (length + kAlign) & ~(kAlign - 1);
+}
+
+/// A null-terminated string starting at `offset`, and where the next part begins. Nothing
+/// when there is no terminator inside the packet — which is what a truncated datagram
+/// looks like, and the reason this cannot use `strlen`.
+struct Part {
+    std::string_view text;
+    std::size_t next = 0;
+};
+
+std::optional<Part> readString(std::span<const std::byte> packet, std::size_t offset) noexcept {
+    for (std::size_t i = offset; i < packet.size(); ++i) {
+        if (packet[i] != std::byte{0}) {
+            continue;
+        }
+        const std::size_t length = i - offset;
+        const std::size_t next = offset + padded(length);
+        if (next > packet.size()) {
+            return std::nullopt; // the padding itself runs off the end
+        }
+        return Part{std::string_view(reinterpret_cast<const char*>(packet.data() + offset), length),
+                    next};
+    }
+    return std::nullopt;
+}
+
+std::optional<std::uint32_t> readBig32(std::span<const std::byte> packet,
+                                       std::size_t offset) noexcept {
+    if (offset + 4 > packet.size()) {
+        return std::nullopt;
+    }
+    return static_cast<std::uint32_t>(packet[offset]) << 24 |
+           static_cast<std::uint32_t>(packet[offset + 1]) << 16 |
+           static_cast<std::uint32_t>(packet[offset + 2]) << 8 |
+           static_cast<std::uint32_t>(packet[offset + 3]);
+}
+
+bool validAddress(std::string_view address) noexcept {
+    if (address.empty() || address.front() != '/') {
+        return false;
+    }
+    for (const char c : address) {
+        if (c < ' ' || c > '~') {
+            return false;
+        }
+    }
+    return true;
+}
+
+} // namespace
+
+std::optional<double> OscView::number(std::size_t index) const noexcept {
+    if (index >= count_) {
+        return std::nullopt;
+    }
+    switch (arguments_[index].type) {
+    case OscArgument::Type::Int32:
+        return static_cast<double>(arguments_[index].asInt);
+    case OscArgument::Type::Float32:
+        return static_cast<double>(arguments_[index].asFloat);
+    case OscArgument::Type::True:
+        return 1.0;
+    case OscArgument::Type::False:
+        return 0.0;
+    case OscArgument::Type::String:
+        break;
+    }
+    return std::nullopt;
+}
+
+std::optional<bool> OscView::flag(std::size_t index) const noexcept {
+    const std::optional<double> value = number(index);
+    if (!value) {
+        return std::nullopt;
+    }
+    return *value != 0.0;
+}
+
+std::optional<OscView> parseOsc(std::span<const std::byte> packet) noexcept {
+    // A packet that is not a whole number of four-byte words cannot be OSC whatever else
+    // is true of it, and checking first means nothing below has to handle a ragged end.
+    if (packet.empty() || packet.size() % kAlign != 0) {
+        return std::nullopt;
+    }
+
+    const std::optional<Part> address = readString(packet, 0);
+    if (!address || !validAddress(address->text)) {
+        return std::nullopt;
+    }
+    // "#bundle" is a container of messages with a timestamp. Refused rather than guessed
+    // at; see the header.
+    if (address->text.front() == '#') {
+        return std::nullopt;
+    }
+
+    OscView view;
+    view.address_ = address->text;
+    if (address->next == packet.size()) {
+        return view; // address only, no type tag string
+    }
+
+    const std::optional<Part> tags = readString(packet, address->next);
+    if (!tags || tags->text.empty() || tags->text.front() != ',') {
+        return std::nullopt;
+    }
+
+    std::size_t offset = tags->next;
+    for (const char tag : tags->text.substr(1)) {
+        if (view.count_ >= OscView::kMaxArguments) {
+            return std::nullopt;
+        }
+        OscArgument& argument = view.arguments_[view.count_];
+        switch (tag) {
+        case 'i': {
+            const std::optional<std::uint32_t> bits = readBig32(packet, offset);
+            if (!bits) {
+                return std::nullopt;
+            }
+            argument.type = OscArgument::Type::Int32;
+            argument.asInt = std::bit_cast<std::int32_t>(*bits);
+            offset += 4;
+            break;
+        }
+        case 'f': {
+            const std::optional<std::uint32_t> bits = readBig32(packet, offset);
+            if (!bits) {
+                return std::nullopt;
+            }
+            argument.type = OscArgument::Type::Float32;
+            argument.asFloat = std::bit_cast<float>(*bits);
+            offset += 4;
+            break;
+        }
+        case 's': {
+            const std::optional<Part> text = readString(packet, offset);
+            if (!text) {
+                return std::nullopt;
+            }
+            argument.type = OscArgument::Type::String;
+            argument.asString = text->text;
+            offset = text->next;
+            break;
+        }
+        case 'T':
+            argument.type = OscArgument::Type::True;
+            break;
+        case 'F':
+            argument.type = OscArgument::Type::False;
+            break;
+        default:
+            // Every other tag has a width this does not know, so the arguments after it
+            // cannot be found. Guessing would mean acting on numbers nobody sent.
+            return std::nullopt;
+        }
+        ++view.count_;
+    }
+    return view;
+}
+
+} // namespace takt4::control
@@ -0,0 +1,86 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <span>
+#include <string_view>
+
+namespace takt4::control {
+
+/// HANDOFF §5.7's half of OSC: reading it.
+///
+/// `output::OscMessage` builds messages and this reads them, and they deliberately share
+/// no code — building is "append and pad", reading is "check everything the sender might
+/// have got wrong", and the two have almost nothing in common but the format.
+///
+/// **Everything arriving here came off a socket**, which is to say from anywhere on the
+/// network. A malformed datagram, a truncated one, a hostile one: the only acceptable
+/// answer is `std::nullopt`. Nothing here throws, allocates, or reads outside the span it
+/// was given.
+
+/// One argument, as the type tag said it was. No conversions are invented: a receiver
+/// asking for an int from a string gets nothing.
+struct OscArgument {
+    enum class Type : char {
+        Int32 = 'i',
+        Float32 = 'f',
+        String = 's',
+        True = 'T',
+        False = 'F',
+    };
+
+    Type type = Type::Int32;
+    std::int32_t asInt = 0;
+    float asFloat = 0.0f;
+    /// Borrowed from the datagram, valid only while it is.
+    std::string_view asString;
+};
+
+/// A parsed OSC 1.0 message. Borrows the buffer it was parsed from: the address and any
+/// string arguments point into the datagram, which has to outlive this.
+class OscView {
+public:
+    /// As many as `output::OscMessage` will build. A message with more is refused rather
+    /// than truncated — silently dropping arguments is how a control surface ends up
+    /// doing something other than what it said.
+    static constexpr std::size_t kMaxArguments = 16;
+
+    std::string_view address() const noexcept { return address_; }
+    std::size_t argumentCount() const noexcept { return count_; }
+    const OscArgument& argument(std::size_t index) const noexcept { return arguments_[index]; }
+
+    /// The argument at `index` as a number, when it is one. `T` and `F` count: a Stream
+    /// Deck sending a boolean means the same as one sending 1 or 0, and refusing it would
+    /// be pedantry the operator pays for.
+    std::optional<double> number(std::size_t index) const noexcept;
+
+    /// §5.7's `<0|1>` arguments. True for a non-zero number or `T`; false for zero or
+    /// `F`; nothing for a message that carried no argument at all, which callers treat as
+    /// "the sender did not say" rather than as false.
+    std::optional<bool> flag(std::size_t index) const noexcept;
+
+private:
+    friend std::optional<OscView> parseOsc(std::span<const std::byte> packet) noexcept;
+
+    std::string_view address_;
+    OscArgument arguments_[kMaxArguments];
+    std::size_t count_ = 0;
+};
+
+/// Parses one datagram, or returns nothing.
+///
+/// Refused: anything not a multiple of four bytes, an address that does not start with
+/// '/' or is not terminated inside the packet, a type tag string that does not start with
+/// ',', a tag this does not know (the argument's width would have to be guessed), an
+/// argument that runs past the end, and more than `kMaxArguments`.
+///
+/// A message with nothing after its address is accepted as one with no arguments. OSC 1.0
+/// requires the type tag string, but enough senders omit it for an address-only message
+/// that refusing them would mean refusing real control surfaces.
+///
+/// **Bundles are not handled** — `#bundle` returns nothing. Nothing in §5.7 needs one, and
+/// accepting a container of messages means deciding what their timestamps mean.
+std::optional<OscView> parseOsc(std::span<const std::byte> packet) noexcept;
+
+} // namespace takt4::control
@@ -0,0 +1,109 @@
+#pragma once
+
+/// The platform's UDP sockets, spelled the same way on all three.
+///
+/// Internal to `core`: this is a shim over `<winsock2.h>` and `<sys/socket.h>`, not an
+/// abstraction, and it pulls the platform's networking headers into whatever includes it.
+/// Nothing outside `core/output` and `core/control` should want it.
+///
+/// It exists because OSC now goes both ways — `output::OscSender` writes datagrams and
+/// `control::OscReceiver` reads them — and the second copy of a reference-counted
+/// `WSAStartup` guard is the sort of duplication that is right until one of them is
+/// fixed and the other is not.
+
+#include <atomic>
+#include <string>
+
+#if defined(_WIN32)
+#include <winsock2.h>
+// ws2tcpip.h must follow winsock2.h.
+#include <ws2tcpip.h>
+#pragma comment(lib, "ws2_32.lib")
+#else
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <cerrno>
+#endif
+
+#include <stdexcept>
+
+namespace takt4::net {
+
+#if defined(_WIN32)
+
+using Socket = SOCKET;
+inline constexpr Socket kInvalidSocket = INVALID_SOCKET;
+
+inline void closeSocket(Socket socket) noexcept {
+    ::closesocket(socket);
+}
+
+inline int lastSocketError() noexcept {
+    return ::WSAGetLastError();
+}
+
+/// Winsock has to be started before any socket call and stopped after the last one.
+/// Everything holding a socket holds one of these, so the library is up exactly while at
+/// least one exists. Windows reference-counts `WSAStartup` itself; the counter here is so
+/// that `WSACleanup` is not called while another socket in this process is still open.
+class WinsockGuard {
+public:
+    WinsockGuard() {
+        if (count_.fetch_add(1, std::memory_order_acq_rel) == 0) {
+            WSADATA data{};
+            const int error = ::WSAStartup(MAKEWORD(2, 2), &data);
+            if (error != 0) {
+                count_.fetch_sub(1, std::memory_order_acq_rel);
+                throw std::runtime_error("WSAStartup failed with " + std::to_string(error));
+            }
+        }
+    }
+    ~WinsockGuard() {
+        if (count_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+            ::WSACleanup();
+        }
+    }
+    /// Copying takes its own reference rather than sharing one.
+    WinsockGuard(const WinsockGuard&) : WinsockGuard() {}
+    WinsockGuard& operator=(const WinsockGuard&) = delete;
+
+private:
+    inline static std::atomic<int> count_{0};
+};
+
+#else
+
+using Socket = int;
+inline constexpr Socket kInvalidSocket = -1;
+
+inline void closeSocket(Socket socket) noexcept {
+    ::close(socket);
+}
+
+inline int lastSocketError() noexcept {
+    return errno;
+}
+
+/// Nothing to start anywhere but Windows.
+struct WinsockGuard {};
+
+#endif
+
+/// "host:port" for an address, numeric, or "?" when it cannot be named. For logs and for
+/// a UI that has to say where a message came from.
+inline std::string describe(const sockaddr* address, socklen_t length) {
+    char host[NI_MAXHOST] = {};
+    char service[NI_MAXSERV] = {};
+    if (::getnameinfo(address, length, host, sizeof host, service, sizeof service,
+                      NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
+        return "?";
+    }
+    return std::string(host) + ":" + service;
+}
+
+} // namespace takt4::net