Swift for System Programming: A New Powerful Tool

Swift — an Unexpected Hero of System Programming

When you hear "system programming," you usually think of hardcore C, assembly, or at worst Rust. Swift? That language for beautiful mobile apps? Turns out, yes. And it's no joke.

Apple has built into Swift not only convenience and safety, but also full control over memory, pointers, and system calls. In this article, we'll explore how Swift can become your primary tool for writing utilities, drivers, network daemons, and even operating system components. Get ready to be surprised — the code will be real, working, and very interesting.

Why Swift? The Three Pillars of System Programming

System programming requires three things: performance, resource control, and the ability to work "close to the metal." Swift provides all of this, plus something extra.

• C-level performance. The LLVM compiler optimizes code no worse than for C or C++. In benchmarks, Swift often outperforms Go and Rust in I/O tasks.
• Direct memory access. Through UnsafePointer, UnsafeMutablePointer, and raw byte manipulation.
• Rich standard library. No need to drag along a bunch of dependencies — everything for working with sockets, files, and processes is already there.

At the same time, Swift remains safe: if you don't use unsafe blocks, the compiler will protect you from buffer overflows and dangling pointers. And when you need to — just write withUnsafePointer and get full control.

Working with Memory: From Bytes to Structures

Let's start with the basics — working with raw memory. Imagine you need to read a binary file and interpret it as an array of structures. In C, you'd struggle with malloc and sizeof. In Swift — elegantly and safely.

Reading a Binary File in Swift

import Foundation

struct Header {    let magic: UInt32    let version: UInt16    let count: UInt16}

func readBinaryFile(path: String) -> Header? {    let data = try? Data(contentsOf: URL(fileURLWithPath: path))    guard let data = data else { return nil }        return data.withUnsafeBytes { (ptr: UnsafeRawBufferPointer) in        guard let baseAddress = ptr.baseAddress else { return nil }        let headerPtr = baseAddress.assumingMemoryBound(to: Header.self)        return headerPtr.pointee    }}

Notice: we don't allocate memory manually. withUnsafeBytes provides a temporary pointer that lives only inside the closure. It's safe, efficient, and reads like good prose.

Creating Structures and Working with Pointers

But what if you need to create a structure in memory and pass its address to a system call? Easy!

struct sockaddr_in {    var sin_len: UInt8 = 0    var sin_family: UInt8 = UInt8(AF_INET)    var sin_port: in_port_t = 0    var sin_addr: in_addr = in_addr(s_addr: 0)    var sin_zero: (UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8) = (0,0,0,0,0,0,0,0)}

var address = sockaddr_in()address.sin_port = CFSwapInt16HostToBig(8080)address.sin_addr.s_addr = inet_addr("127.0.0.1")

let ptr = withUnsafePointer(to: &address) { $0 }let rawPtr = UnsafeRawPointer(ptr)

This code is the foundation for working with sockets at a low level. We manually define the structure, fill in the fields, and get a raw pointer to pass to connect or bind.

System Calls and POSIX API

Swift plays nicely with POSIX. You can call open, read, write, fork, exec — just like in the good old days, but with 21st-century syntax.

Creating fork + exec in Swift

import Darwin

func spawnProcess(path: String, args: [Str