Swift for System Programming: The Ultimate Guide to

Swift for System Programming: The Ultimate Guide to Low-Level Development

Swift has evolved far beyond its origins as a language for iOS and macOS app development. With its modern syntax, strong type system, and growing ecosystem, Swift is increasingly being used for system programming tasks that were once the exclusive domain of C, C++, and Rust. This guide will walk you through everything you need to know to use Swift for system-level programming, from memory management to interacting with low-level operating system APIs.

What Is System Programming in Swift?

System programming refers to writing software that provides services to the computer hardware or to other software. This includes operating system components, device drivers, file systems, network stacks, command-line utilities, and performance-critical libraries. Swift supports system programming through several key features:

• Direct memory access via UnsafePointer and related types
• Seamless interoperability with C libraries and system APIs
• Manual memory management when needed, alongside its automatic reference counting (ARC)
• Support for low-level concurrency primitives
• Access to POSIX APIs and platform-specific frameworks

Why Swift Matters for System Programming

Swift brings several advantages to system programming that make it an attractive alternative to traditional choices:

• Safety by default: Swift's type system, optionals, and bounds checking catch many common programming errors at compile time or runtime that would otherwise lead to crashes or security vulnerabilities.
• Readability: Swift's clean syntax makes system code easier to read and maintain compared to C or C++.
• C interoperability: Swift can directly call C functions, use C structs, and work with C pointers, making it easy to leverage existing system libraries.
• Performance: Swift compiles to native machine code using LLVM, delivering performance comparable to C in many scenarios.
• Modern language features: Generics, protocol-oriented programming, and structured concurrency help write reusable, efficient system code.
• Active ecosystem: The Swift on Server community and Swift System library provide growing support for cross-platform system programming.

Setting Up Your Environment

To get started with Swift system programming, you need a working Swift toolchain. On macOS, Swift comes bundled with Xcode. On Linux, you can install Swift via the official toolchain from swift.org. On Windows, Swift is also now supported with official builds.

For cross-platform system programming, the Swift System library is essential. It provides idiomatic Swift interfaces to low-level system APIs across platforms. Add it to your Package.swift file:

// swift-tools-version:5.9
import PackageDescription

let package = Package(
    name: "SystemTool",
    dependencies: [
        .package(url: "https://github.com/apple/swift-system", from: "1.3.0")
    ],
    targets: [
        .executableTarget(
            name: "SystemTool",
            dependencies: [
                .product(name: "SystemPackage", package: "swift-system")
            ]
        )
    ]
)

With this setup, you can import SystemPackage in your Swift files and access a wide range of system APIs with type-safe Swift wrappers.

Working with Pointers and Memory

System programming often requires direct memory manipulation. Swift provides a family of unsafe pointer types that give you low-level control while still being more expressive than raw C pointers.

Understanding Swift's Pointer Types

Swift offers several pointer types, each serving a different purpose:

• UnsafePointer<T> — A pointer to an immutable value of type T
• UnsafeMutablePointer<T> — A pointer to a mutable value of type T
• UnsafeRawPointer — A type-erased pointer to raw bytes (read-only)
• UnsafeMutableRawPointer — A mutable type-erased pointer to raw bytes
• UnsafeBufferPointer<T> — A pointer to a collection of values with a count
• UnsafeMutableBufferPointer<T> — A mutable collection pointer with a count

Allocating and Deallocating Memory

Here is a practical example of allocating memory, writing to it, and reading from it:

import Foundation

func demonstrateMemoryAllocation() {
    // Allocate memory for a single Int32
    let pointer = UnsafeMutablePointer<Int32>.allocate(capacity: 1)
    pointer.initialize(to: 42)

    print("Value at pointer: \(pointer.pointee)")

    // Deinitialize and deallocate to avoid memory leaks
    pointer.deinitialize(count: 1)
    pointer.deallocate()
}

func demonstrateBufferAllocation() {
    // Allocate memory for an array of 5 Int32 values
    let count = 5
    let buffer = UnsafeMutableBufferPointer<Int32>.allocate(capacity: count)

    // Initialize values
    for (index, _) in buffer.enumerated() {
        buffer[index] = Int32(index * 10)
    }

    // Read values
    for value in buffer {
        print("Buffer value: \(value)")
    }

    // Clean up
    buffer.deallocate()
}

demonstrateMemoryAllocation()
demonstrateBufferAllocation()

Converting Between Swift Types and Pointers

Often you need to pass Swift data to C APIs that expect pointers. Swift provides several ways to do this safely:

import Foundation

func processWithCPointer() {
    var numbers: [Int32] = [10, 20, 30, 40, 50]

    // Use withUnsafeMutableBufferPointer to get a temporary pointer
    numbers.withUnsafeMutableBufferPointer { buffer in
        // buffer is UnsafeMutableBufferPointer<Int32>
        // It is only valid within this closure
        for i in 0..<buffer.count {
            buffer[i] *= 2
        }
    }

    print("Doubled numbers: \(numbers)")
}

func passStringToCFunction() {
    let message = "Hello, System Programming!"

    message.withCString { cString in
        // cString is a UnsafePointer<CChar>
        // Calculate the length using the C strlen function
        let length = strlen(cString)
        print("String length in C: \(length)")
    }
}

processWithCPointer()
passStringToCFunction()

The withUnsafeMutableBufferPointer and withCString methods ensure that the pointer is only valid within the closure, preventing dangling pointer issues that are common in C.

File I/O and Filesystem Operations

File operations are a core part of system programming. Using the Swift System library, you can perform file I/O in a cross-platform way.

Reading and Writing Files

import SystemPackage
import Foundation

func writeToFile() throws {
    // Open or create a file for writing
    let filePath = FilePath("output.txt")
    let fd = try FileDescriptor.open(
        filePath,
        .writeOnly,
        options: [.create, .truncate],
        permissions: [.ownerReadWrite, .groupRead, .otherRead]
    )

    defer {
        try? fd.close()
    }

    let data = "Hello from Swift System Programming!\n".data(using: .utf8)!
    let bytesWritten = try data.withUnsafeBytes { buffer in
        try fd.write(buffer)
    }

    print("Wrote \(bytesWritten) bytes to \(filePath)")
}

func readFromFile() throws {
    let filePath = FilePath("output.txt")
    let fd = try FileDescriptor.open(filePath, .readOnly)

    defer {
        try? fd.close()
    }

    var buffer = [UInt8](repeating: 0, count: 256)
    let bytesRead = try buffer.withUnsafeMutableBytes { mutableBuffer in
        try fd.read(into: mutableBuffer)
    }

    let content = String(bytes: buffer.prefix(bytesRead), encoding: .utf8)
    print("Read \(bytesRead) bytes: \(content ?? "")")
}

do {
    try writeToFile()
    try readFromFile()
} catch {
    print("Error: \(error)")
}

Working with Directories

import SystemPackage
import Foundation

func listDirectoryContents(at path: String) throws {
    let dirPath = FilePath(path)
    let fd = try FileDescriptor.open(dirPath, .readOnly, options: [.directory])

    defer {
        try? fd.close()
    }

    var buffer = [UInt8](repeating: 0, count: 4096)
    var entries: [String] = []

    while true {
        let bytesRead = try buffer.withUnsafeMutableBytes { mutableBuffer in
            try fd.read(into: mutableBuffer)
        }

        if bytesRead == 0 { break }

        // Parse directory entries (simplified approach)
        // In production, use the proper platform-specific dirent parsing
        let chunk = String(bytes: buffer.prefix(bytesRead), encoding: .utf8) ?? ""
        entries.append(chunk)
    }

    print("Directory listing for \(path):")
    for entry in entries {
        print("  \(entry)")
    }
}

func createDirectory() throws {
    let dirPath = FilePath("test_directory")
    try FileManager.default.createDirectory(
        atPath: "test_directory",
        withIntermediateDirectories: true,
        attributes: [.posixPermissions: 0o755]
    )
    print("Created directory: \(dirPath)")
}

try createDirectory()

Interacting with C APIs

One of Swift's greatest strengths for system programming is its ability to interoperate with C. You can import C headers directly and call C functions from Swift code.

Importing C Libraries

To use a C library in Swift, you create a module map or use a system module. Here is an example of using POSIX functions directly:

import Foundation
#if canImport(Glibc)
import Glibc
#elseif canImport(Darwin)
import Darwin
#endif

func getSystemInfo() {
    // Get the current process ID
    let pid = getpid()
    print("Process ID: \(pid)")

    // Get the parent process ID
    let ppid = getppid()
    print("Parent Process ID: \(ppid)")

    // Get the current working directory
    var cwdBuffer = [CChar](repeating: 0, count: 1024)
    if let cwd = getcwd(&cwdBuffer, cwdBuffer.count) {
        print("Current working directory: \(String(cString: cwd))")
    }

    // Get system hostname
    var hostnameBuffer = [CChar](repeating: 0, count: 256)
    if gethostname(&hostnameBuffer, hostnameBuffer.count) == 0 {
        print("Hostname: \(String(cString: hostnameBuffer))")
    }
}

getSystemInfo()

Working with C Structs

Swift can directly use C structs. Here is an example using the stat struct to get file information:

import Foundation
#if canImport(Glibc)
import Glibc
#elseif canImport(Darwin)
import Darwin
#endif

func getFileInfo(forPath path: String) {
    var fileStat = stat()

    let result = stat(path, &fileStat)

    if result != 0 {
        let errorMessage = String(cString: strerror(errno))
        print("Failed to stat \(path): \(errorMessage)")
        return
    }

    print("File: \(path)")
    print("  Size: \(fileStat.st_size) bytes")
    print("  Inode: \(fileStat.st_ino)")
    print("  Device ID: \(fileStat.st_dev)")

    // Check file type
    let mode = fileStat.st_mode
    if (mode & S_IFMT) == S_IFREG {
        print("  Type: Regular file")
    } else if (mode & S_IFMT) == S_IFDIR {
        print("  Type: Directory")
    } else if (mode & S_IFMT) == S_IFLNK {
        print("  Type: Symbolic link")
    }

    // Check permissions
    let isReadable = (mode & S_IRUSR) != 0
    let isWritable = (mode & S_IWUSR) != 0
    let isExecutable = (mode & S_IXUSR) != 0
    print("  Owner read: \(isReadable), write: \(isWritable), execute: \(isExecutable)")
}

getFileInfo(forPath: "/etc/hosts")

Using C Function Pointers and Callbacks

Some C APIs require callback functions. Swift can pass closures to C functions using @convention(c):

import Foundation
#if canImport(Glibc)
import Glibc
#elseif canImport(Darwin)
import Darwin
#endif

// Example: Using qsort with a C callback
func sortArrayWithQSort() {
    var numbers: [Int32] = [42, 7, 19, 88, 3, 56, 12]

    // Define a C-compatible comparison function
    let compare: @convention(c) (UnsafeRawPointer?, UnsafeRawPointer?) -> Int32 = { a, b in
        guard let a = a, let b = b else { return 0 }
        let valueA = a.load(as: Int32.self)
        let valueB = b.load(as: Int32.self)
        if valueA < valueB { return -1 }
        if valueA > valueB { return 1 }
        return 0
    }

    numbers.withUnsafeMutableBufferPointer { buffer in
        qsort(buffer.baseAddress, buffer.count, MemoryLayout<Int32>.size, compare)
    }

    print("Sorted: \(numbers)")
}

sortArrayWithQSort()

Concurrency and Threading

System programming often requires managing multiple threads and concurrent operations. Swift provides both high-level concurrency (async/await, actors) and access to lower-level threading primitives.

Using POSIX Threads

import Foundation
#if canImport(Glibc)
import Glibc
#elseif canImport(Darwin)
import Darwin
#endif

class ThreadContext {
    let id: Int
    let iterations: Int

    init(id: Int, iterations: Int) {
        self.id = id
        self.iterations = iterations
    }
}

// Thread function must be @convention(c) and take/return opaque pointers
let threadFunc: @convention(c) (UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer? = { arg in
    guard let arg = arg else { return nil }
    let context = Unmanaged<ThreadContext>.fromOpaque(arg).takeRetainedValue()

    for i in 0..<context.iterations {
        print("Thread \(context.id): iteration \(i)")
        usleep(100_000) // 100ms
    }

    return nil
}

func runMultipleThreads() {
    let threadCount = 3
    var threads: [pthread_t] = []
    var threadIds: [Int] = []

    for i in 0..<threadCount {
        let context = ThreadContext(id: i, iterations: 5)
        let contextPointer = Unmanaged.passRetained(context).toOpaque()

        var threadId = pthread_t()
        let result = pthread_create(&threadId, nil, threadFunc, contextPointer)

        if result == 0 {
            threads.append(threadId)
            threadIds.append(i)
            print("Created thread \(i)")
        } else {
            print("Failed to create thread \(i): error \(result)")
        }
    }

    // Wait for all threads to complete
    for (index, thread) in threads.enumerated() {
        pthread_join(thread, nil)
        print("Thread \(threadIds[index]) completed")
    }
}

runMultipleThreads()

Using Swift's Modern Concurrency

For most use cases, Swift's async/await and structured concurrency are preferred over raw POSIX threads:

import Foundation

func performSystemTask(id: Int) async throws -> String {
    // Simulate I/O-bound system work
    try await Task.sleep(nanoseconds: 500_000_000) // 500ms
    return "Task \(id) completed at \(Date())"
}

func runConcurrentSystemTasks() async {
    await withTaskGroup(of: String.self) { group in
        for i in 1...5 {
            group.addTask {
                return try! await performSystemTask(id: i)
            }
        }

        for await result in group {
            print(result)
        }
    }
}

// Run the concurrent tasks
Task {
    await runConcurrentSystemTasks()
}

// Keep the program running long enough
Thread.sleep(forTimeInterval: 3)

Using Dispatch Semaphores for Resource Control

import Foundation

func limitedConcurrentAccess() {
    let semaphore = DispatchSemaphore(value: 2) // Allow 2 concurrent accesses
    let queue = DispatchQueue(label: "com.system.concurrent", attributes: .concurrent)
    let group = DispatchGroup()

    for i in 1...6 {
        group.enter()
        queue.async {
            semaphore.wait()
            print("Starting task \(i) on thread \(Thread.current.description.prefix(20))")

            // Simulate work
            Thread.sleep(forTimeInterval: Double.random(in: 0.5...1.5))

            print("Finished task \(i)")
            semaphore.signal()
            group.leave()
        }
    }

    group.wait()
    print("All tasks completed")
}

limitedConcurrentAccess()

Network Programming

System programming often involves network communication. Swift can use POSIX socket APIs directly for low-level network programming.

Creating a TCP Server

import Foundation
#if canImport(Glibc)
import Glibc
#elseif canImport(Darwin)
import Darwin
#endif

class TCPServer {
    private var serverSocket: Int32 = -1
    private let port: UInt16
    private var isRunning = false

    init(port: UInt16) {
        self.port = port
    }

    func start() throws {
        // Create a socket
        serverSocket = socket(AF_INET, Int32(SOCK_STREAM.rawValue), 0)
        if serverSocket < 0 {
            throw NSError(domain: "TCPServer", code: 1,
                          userInfo: [NSLocalizedDescriptionKey: "Failed to create socket"])
        }

        // Allow socket reuse
        var reuse: Int32 = 1
        setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &reuse, socklen_t(MemoryLayout.size(ofValue: reuse)))

        // Bind to address and port
        var addr = sockaddr_in()
        addr.sin_family = sa_family_t(AF_INET)
        addr.sin_port = port.bigEndian
        addr.sin_addr.s_addr = INADDR_ANY.bigEndian

        let bindResult = withUnsafePointer(to: &addr) { ptr in
            ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockaddrPtr in
                bind(serverSocket, sockaddrPtr, socklen_t(MemoryLayout<sockaddr_in>.size))
            }
        }

        if bindResult < 0 {
            throw NSError(domain: "TCPServer", code: 2,
                          userInfo: [NSLocalizedDescriptionKey: "Failed to bind socket"])
        }

        // Start listening
        if listen(serverSocket, 5) < 0 {
            throw NSError(domain: "TCPServer", code: 3,
                          userInfo: [NSLocalizedDescriptionKey: "Failed to listen"])
        }

        isRunning = true
        print("Server listening on port \(port)")

        acceptConnections()
    }

    private func acceptConnections() {
        while isRunning {
            var clientAddr = sockaddr_in()
            var clientAddrLen = socklen_t(MemoryLayout<sockaddr_in>.size)

            let clientSocket = withUnsafeMutablePointer(to: &clientAddr) { ptr in
                ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockaddrPtr in
                    accept(serverSocket, sockaddrPtr, &clientAddrLen)
                }
            }

            if clientSocket < 0 {
                print("Failed to accept connection")
                continue
            }

            print("Client connected")

            // Handle client in a background thread
            DispatchQueue.global().async {
                self.handleClient(clientSocket)
            }
        }
    }

    private func handleClient(_ clientSocket: Int32) {
        defer {
            close(clientSocket)
        }

        var buffer = [UInt8](repeating: 0, count: 1024)

        while true {
            let bytesRead = recv(clientSocket, &buffer, buffer.count, 0)
            if bytesRead <= 0 {
                print("Client disconnected")
                break
            }

            let receivedData = String(bytes: buffer.prefix(bytesRead), encoding: .utf8) ?? ""
            print("Received: \(receivedData.trimmingCharacters(in: .whitespacesAndNewlines))")

            // Echo back with a prefix
            let response = "Server echo: \(receivedData)"
            let responseData = response.data(using: .utf8)!
            responseData.withUnsafeBytes { ptr in
                _ = send(clientSocket, ptr.baseAddress, responseData.count, 0)
            }
        }
    }

    func stop() {
        isRunning = false
        if serverSocket >= 0 {
            close(serverSocket)
        }
    }
}

// Start the server (this will block)
// let server = TCPServer(port: 8080)
// try? server.start()

Creating a TCP Client

import Foundation
#if canImport(Glibc)
import Glibc
#elseif canImport(Darwin)
import Darwin
#endif

class TCPClient {
    private var clientSocket: Int32 = -1

    func connect(to host: String, port: UInt16) throws {
        clientSocket = socket(AF_INET, Int32(SOCK_STREAM.rawValue), 0)
        if clientSocket < 0 {
            throw NSError(domain: "TCPClient", code: 1,
                          userInfo: [NSLocalizedDescriptionKey: "Failed to create socket"])
        }

        var addr = sockaddr_in()
        addr.sin_family = sa_family_t(AF_INET)
        addr.sin_port = port.bigEndian

        // Convert hostname to IP address
        if inet_pton(AF_INET, host, &addr.sin_addr) <= 0 {
            throw NSError(domain: "TCPClient", code: 2,
                          userInfo: [NSLocalizedDescriptionKey: "Invalid address"])
        }

        let connectResult = withUnsafePointer(to: &addr) { ptr in
            ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockaddrPtr in
                connect(clientSocket, sockaddrPtr, socklen_t(MemoryLayout<sockaddr_in>.size))
            }
        }

        if connectResult < 0 {
            throw NSError(domain: "TCPClient", code: 3,
                          userInfo: [NSLocalizedDescriptionKey: "Connection failed"])
        }

        print("Connected to \(host):\(port)")
    }

    func send(message: String) throws -> String {
        let data = message.data(using: .utf8)!
        let bytesSent = data.withUnsafeBytes { ptr in
            send(clientSocket, ptr.baseAddress, data.count, 0)
        }

        if bytesSent < 0 {
            throw NSError(domain: "TCPClient", code: 4,
                          userInfo: [NSLocalizedDescriptionKey: "Send failed"])
        }

        var buffer = [UInt8](repeating: 0, count: 1024)
        let bytesRead = recv(clientSocket, &buffer, buffer.count, 0)

        if bytesRead < 0 {
            throw NSError(domain: "TCPClient", code: 5,
                          userInfo: [NSLocalizedDescriptionKey: "Receive failed"])
        }

        return String(bytes: buffer.prefix(bytesRead), encoding: .utf8) ?? ""
    }

    func disconnect() {
        if clientSocket >= 0 {
            close(clientSocket)
            clientSocket = -1
        }
    }
}

// Example usage:
// let client = TCPClient()
// try client.connect(to: "127.0.0.1", port: 8080)
// let response = try client.send(message: "Hello, Server!\n")
// print("Response: \(response)")
// client.disconnect()

Process Management

System programming often involves creating and managing processes. Swift can use POSIX process management functions.

Spawning Child Processes

import Foundation
#if canImport(Glibc)
import Glibc
#elseif canImport(Darwin)
import Darwin
#endif

func spawnChildProcess(command: String, args: [String]) -> Int32 {
    // Convert arguments to C strings
    var cArgs: [UnsafeMutablePointer<CChar>?] = []
    cArgs.append(strdup(command))
    for arg in args {
        cArgs.append(strdup(arg))
    }
    cArgs.append(nil)

    defer {
        for ptr in cArgs {
            if ptr != nil {
                free(ptr)
            }
        }
    }

    var pid = pid_t()

    // Using posix_spawn for more control
    var actions = posix_spawn_file_actions_t()
    posix_spawn_file_actions_init(&actions)

    // Inherit standard file descriptors
    posix_spawn_file_actions_adddup2(&actions, 0, 0)
    posix_spawn_file_actions_adddup2(&actions, 1, 1)
    posix_spawn_file_actions_adddup2(&actions, 2, 2)

    defer {
        posix_spawn_file_actions_destroy(&actions)
    }

    var attrs = posix_spawnattr_t()
    posix_spawnattr_init(&attrs)
    defer {
        posix_spawnattr_destroy(&attrs)
    }

    let spawnResult = cArgs.withUnsafeBufferPointer { buffer in
        posix_spawn(&pid, command, &actions, &attrs, buffer.baseAddress, nil)
    }

    if spawnResult != 0 {
        print("posix_spawn failed with error: \(spawnResult)")
        return -1
    }

    print("Spawned process with PID: \(pid)")

    // Wait for the child process to complete
    var status: Int32 = 0
    waitpid(pid, &status, 0)

    if status != 0 {
        print("Child process exited with status: \(status)")
    }

    return status
}

// Example: Run the 'ls' command
// let status = spawnChildProcess(command: "/bin/ls", args: ["-la", "/tmp"])
// print("Exit status: \(status)")

Using Process for Higher-Level Process Management

import Foundation

func runProcess(executable: String, arguments: [String]) throws -> (stdout: String, stderr: String, exitCode: Int32) {
    let process = Process()
    process.executableURL = URL(fileURLWithPath: executable)
    process.arguments = arguments

    let stdoutPipe = Pipe()
    let stderrPipe = Pipe()
    process.standardOutput = stdoutPipe
    process.standardError = stderrPipe

    try process.run()
    process.waitUntilExit()

    let stdoutData = stdoutPipe.fileHandleForReading.readDataToEndOfFile()
    let stderrData = stderrPipe.fileHandleForReading.readDataToEndOfFile()

    let stdout = String(data: stdoutData, encoding: .utf8) ?? ""
    let stderr = String(data: stderrData, encoding: .utf8) ?? ""

    return (stdout, stderr, process.terminationStatus)
}

do {
    let result = try runProcess(executable: "/usr/bin/env", arguments: [])
    print("Exit code: \(result.exitCode)")
    print("STDOUT:\n\(result.stdout)")
    if !result.stderr.isEmpty {
        print("STDERR:\n\(result.stderr)")
    }
} catch {
    print("Failed to run process: \(error)")
}

Handling Signals

import Foundation
#if canImport(Glibc)
import Glibc
#elseif canImport(Darwin)
import Darwin
#endif

// Global flag for signal handling
var shouldExit = false

// Signal handler must be @convention(c)
let signalHandler: @convention(c) (Int32) -> Void = { signal in
    print("\nReceived signal: \(signal)")
    shouldExit = true
}

func setupSignalHandlers() {
    signal(SIGINT, signalHandler)
    signal(SIGTERM, signalHandler)

    print("Signal handlers installed. Press Ctrl+C to exit.")

    // Main loop
    var counter = 0
    while !shouldExit {
        counter += 1
        print("Working... (\(counter))")
        sleep(1)
    }

    print("Shutting down gracefully...")
}

setupSignalHandlers()

Memory-Mapped Files

Memory-mapped files allow you to access file contents as if they were in memory, which is highly efficient for large files:

import Foundation
#if canImport(Glibc)
import Glibc
#elseif canImport(Darwin)
import Darwin
#endif

func memoryMapFile(at path: String) throws {
    // Open the file
    let fd = open(path, O_RDONLY)
    if fd < 0 {
        throw NSError(domain: "MMap", code: 1,
                      userInfo: [NSLocalizedDescriptionKey: "Cannot open file: \(path)"])
    }
    defer { close(fd) }

    // Get file size
    let fileSize = lseek(fd, 0, SEEK_END)
    if fileSize <= 0 {
        throw NSError(domain: "MMap", code: 2,
                      userInfo: [NSLocalizedDescriptionKey: "File is empty or error reading size"])
    }
    lseek(fd, 0, SEEK_SET)

    // Map the file into memory
    let mapped = mmap(nil, Int(fileSize), PROT_READ, MAP_PRIVATE, fd, 0)
    if mapped == MAP_FAILED {
        throw NSError(domain: "MMap", code: 3,
                      userInfo: [NSLocalizedDescriptionKey: "mmap failed"])
    }
    defer {
        munmap(mapped, Int(fileSize))
    }

    // Access the mapped memory
    let buffer = mapped!.assumingMemoryBound(to: UInt8.self)
    let data = Data(bytes: buffer, count: Int(fileSize))

    // Process the data
    print("Mapped \(fileSize) bytes from \(path)")

    // Example: Count lines in the file
    let lineCount = data.filter { $0 == UInt8(ascii: "\n") }.count
    print("Line count: \(lineCount)")

    // Example: Print first 200 characters
    if let preview = String(data: data.prefix(200), encoding: .utf8) {
        print("Preview:\n\(preview)")
    }
}

// Create a test file first
let testContent = """
Line 1: Hello World
Line 2: Swift System Programming
Line 3: Memory Mapped Files
Line 4: Efficient I/O
Line 5: End of file
"""
try? testContent.write(toFile: "/tmp/test_mmap.txt", atomically: true, encoding: .utf8)

// Map and read the file
try? memoryMapFile(at: "/tmp/test_mmap.txt")

Best Practices for Swift System Programming

1. Prefer Safe Abstractions Over Raw Pointers

Whenever possible, use Swift's safe types and APIs instead of raw unsafe pointers. Only drop down to unsafe APIs when absolutely necessary, and always encapsulate unsafe code behind a safe interface.

// Bad: Exposing unsafe pointers throughout your code
func processData(_ data: UnsafeMutableRawPointer, length: Int) {
    // Unsafe code scattered everywhere
}

// Good: Encapsulate unsafe code behind a safe API
struct SafeBuffer {
    private let pointer: UnsafeMutableRawPointer
    public let count: Int

    init(count: Int) {
        self.pointer = UnsafeMutableRawPointer.allocate(byteCount: count, alignment: 8)
        self.count = count
    }

    func getByte(at index: Int) -> UInt8? {
        guard index >= 0 && index < count else { return nil }
        return pointer.load(fromByteOffset: index, as: UInt8.self)
    }

    func setByte(_ value: UInt8, at index: Int) {
        guard index >= 0 && index < count else { return }
        pointer.storeBytes(of: value, toByteOffset: index, as: UInt8.self)
    }

    deinit {
        pointer.deallocate()
    }
}

2. Always Clean Up Resources

Use defer blocks to ensure resources are cleaned up, even when errors occur:

func safeFileOperation(path: String) throws {
    let fd = open(path, O_RDONLY)
    guard fd >= 0 else {
        throw NSError(domain: "FileOp", code: 1,
                      userInfo: [NSLocalizedDescriptionKey: "Cannot open file"])
    }

    // Ensure the file descriptor is closed no matter what
    defer {
        close(fd)
    }

    // Perform operations...
    var buffer = [UInt8](repeating: 0, count: 1024)
    let bytesRead = read(fd, &buffer, buffer.count)

    if bytesRead < 0 {
        // Even if this throws, defer will still close the fd
        throw NSError(domain: "FileOp", code: 2,
                      userInfo: [NSLocalizedDescriptionKey: "Read failed"])
    }

    print("Read \(bytesRead) bytes")
}

3. Handle Errors Properly

System calls can fail in many ways. Always check return values and use errno to understand failures:

import Foundation
#if canImport(Glibc)
import Glibc
#elseif canImport(Darwin)
import Darwin
#endif

enum SystemError: Error {
    case syscallFailed(name: String, errno: Int32, message: String)
}

func checkSyscall(_ name: String, _ result: Int32) throws -> Int32 {
    if result < 0 {
        let message = String(cString: strerror(errno))
        throw SystemError.syscallFailed(name: name, errno: errno, message: message)
    }
    return result
}

func safeOpen(path: String, flags: Int32) throws -> Int32 {
    let fd = open(path, flags)
    return try checkSyscall("open", fd)
}

// Usage
do {
    let fd = try safeOpen(path: "/etc/hosts", flags: O_RDONLY)
    defer { close(fd) }
    print("Successfully opened file, fd: \(fd)")
} catch SystemError.syscallFailed(let name, let errno, let message) {
    print("Syscall '\(name)' failed (errno \(errno)): \(message)")
} catch {
    print("Unexpected error: \(error)")
}

4. Use Platform Conditionals for Cross-Platform Code

import Foundation

#if canImport(Glibc)
import Glibc
#elseif canImport(Darwin)
import Darwin
#endif

struct PlatformInfo {
    static var isLinux: Bool {
        #if os(Linux)
        return true
        #else
        return false
        #endif