Swift 6.3 深度解析：官方 Android 支持、C 互操作革命与嵌入式编程新纪元

2026年4月，苹果正式发布 Swift 6.3，这是一个具有里程碑意义的版本。如果说 Swift 6.0 重新定义了并发安全模型，那么 6.3 则彻底打破了平台边界——官方 Android SDK 正式发布，C 互操作能力迎来革命性升级，嵌入式编程支持持续扩展。这三大利器让 Swift 从 Apple 生态的"专属语言"蜕变为真正的跨平台系统编程语言。

本文将从底层原理到实战代码，全方位拆解 Swift 6.3 的技术内核。

一、Android SDK：从"能跑"到"官方支持"的跨越

1.1 历史：Swift 与 Android 的曲折姻缘

Swift 从诞生之初就具备跨平台基因。2015年开源后，社区便开始了 Android 移植工作。但很长一段时间里，Swift 在 Android 上的状态可以用四个字概括："能跑，但..."

• 没有官方 SDK，需要手动配置 NDK、工具链
• 只能编译命令行程序，无法调用 Android API
• 缺乏 UI 框架支持，开发体验极其原始
• 调试困难，没有官方 IDE 集成

这导致 Swift 在 Android 领域长期处于"玩具"状态——你可以在 Android 上跑 Swift 算法，但无法开发真正的 App。

1.2 Swift 6.3 的官方 Android SDK 架构

Swift 6.3 带来了根本性改变。苹果发布了一套完整的 Android SDK，其架构如下：

┌─────────────────────────────────────────────────────────┐
│                    Swift Android SDK                     │
├─────────────────────────────────────────────────────────┤
│  Swift Android Runtime (libswiftandroid.so)              │
│    ├─ Android-specific standard library extensions       │
│    ├─ JNI bridge layer                                   │
│    └─ Platform abstraction layer                         │
├─────────────────────────────────────────────────────────┤
│  Android Platform APIs (Swift bindings)                  │
│    ├─ android.app.*                                      │
│    ├─ android.content.*                                  │
│    ├─ android.view.*                                     │
│    └─ android.widget.*                                   │
├─────────────────────────────────────────────────────────┤
│  Interop Layer                                           │
│    ├─ Swift ↔ Kotlin/Java (JNI)                          │
│    ├─ Swift ↔ C/C++ (直接调用)                           │
│    └─ Gradle Plugin integration                          │
└─────────────────────────────────────────────────────────┘

核心组件解析：

Swift Android Runtime：一个定制的 Swift 运行时库（libswiftandroid.so），针对 Android 平台进行了优化，包括：

• 内存管理适配（使用 Android 的 ashmem 机制）
• 线程模型适配（与 Android 的 ThreadLocal、Handler 协同）
• 异常处理适配（与 Android 的信号处理兼容）

JNI Bridge Layer：Swift 6.3 提供了自动化的 JNI 桥接能力，让 Swift 代码可以无缝调用 Java/Kotlin 代码，反之亦然。

Platform APIs Bindings：Swift 团队为核心 Android API 生成了 Swift 绑定，开发者可以用原生 Swift 语法调用 Android API。

1.3 实战：创建第一个 Swift Android 应用

让我们通过一个完整的示例，体验 Swift Android 开发流程。

环境准备

首先安装 Swift 6.3 Android SDK：

# macOS / Linux
$ swift sdk install android-arm64 \
    --url https://download.swift.org/swift-6.3-release/android/swift-6.3-RELEASE-android-arm64.tar.gz

# 验证安装
$ swift sdk list
android-arm64  swift-6.3-RELEASE  /path/to/sdk

创建项目

使用 Swift Package Manager 创建跨平台项目：

$ mkdir SwiftAndroidDemo && cd SwiftAndroidDemo
$ swift package init --type executable --name SwiftAndroidDemo

Package.swift 配置

// swift-tools-version: 6.3
import PackageDescription

let package = Package(
    name: "SwiftAndroidDemo",
    platforms: [
        .iOS(.v18),
        .macOS(.v15),
        .android("24")  // Android API 24+
    ],
    products: [
        .executable(name: "SwiftAndroidDemo", targets: ["SwiftAndroidDemo"]),
    ],
    targets: [
        .executableTarget(
            name: "SwiftAndroidDemo",
            path: "Sources"
        ),
    ]
)

Android Activity 实现（Swift 版）

// Sources/SwiftAndroidDemo/MainActivity.swift
import AndroidKit
import AndroidApp

@AndroidClass("android.app.Activity")
class MainActivity: Activity {
    
    private var textView: TextView?
    private var counter = 0
    
    override func onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState: savedInstanceState)
        
        // 创建布局
        let layout = LinearLayout(context: self)
        layout.orientation = .vertical
        layout.gravity = .center
        
        // 创建文本视图
        let textView = TextView(context: self)
        textView.text = "Hello from Swift 6.3!"
        textView.textSize = 24
        textView.setTextColor(.black)
        layout.addView(textView, params: LayoutParams(
            width: .wrapContent,
            height: .wrapContent,
            margins: Edges(all: 16)
        ))
        self.textView = textView
        
        // 创建按钮
        let button = Button(context: self)
        button.text = "点击计数"
        button.setOnClickListener { [weak self] in
            self?.onButtonClicked()
        }
        layout.addView(button, params: LayoutParams(
            width: .wrapContent,
            height: .wrapContent,
            margins: Edges(all: 16)
        ))
        
        setContentView(layout)
    }
    
    private func onButtonClicked() {
        counter += 1
        textView?.text = "点击次数: \(counter)"
    }
}

构建与部署

# 编译为 Android APK
$ swift build --sdk android-arm64 --configuration release

# 使用 Gradle 打包（集成到现有 Android 项目）
$ ./gradlew assembleDebug

# 安装到设备
$ adb install -r app/build/outputs/apk/debug/app-debug.apk

1.4 Swift ↔ Kotlin 互操作：JNI 桥接深度解析

Swift 6.3 提供了自动化的 JNI 桥接能力，这是其核心创新之一。

从 Swift 调用 Kotlin/Java

import AndroidInterop

// 调用 Kotlin 单例
val sharedPreferences = SharedPreferences.default(context: this)

// 调用 Kotlin 方法
let data = sharedPreferences.getString(key: "user_token", defaultValue: "")

// 调用 Kotlin 伴生对象方法
val deviceId = UUID.randomUUID().toString()

底层，Swift 编译器会自动生成 JNI 调用代码：

// 生成的桥接代码（简化版）
func sharedPreferences_default(context: Context) -> SharedPreferences {
    let jni = JNI.shared
    let cls = jni.findClass("android/content/SharedPreferences")
    let method = jni.getStaticMethodID(cls, "getDefault", "(Landroid/content/Context;)Landroid/content/SharedPreferences;")
    return jni.callStaticObjectMethod(cls, method, context)
}

从 Kotlin 调用 Swift

// Kotlin 代码
import swift.interop.SwiftRuntime

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 调用 Swift 函数
        val swiftResult = SwiftRuntime.callSwiftFunction(
            "calculateFibonacci",
            args = arrayOf(50)
        )
        Log.d("Swift", "Fibonacci(50) = $swiftResult")
    }
}

Swift 端需要使用 @objc 暴露函数：

@objc public func calculateFibonacci(_ n: Int) -> Int64 {
    // 使用 Swift 6 的并发模型
    Task {
        return await fibonacciAsync(n)
    }
}

1.5 与现有 Android 项目集成

Swift 6.3 提供了 Gradle 插件，支持将 Swift 模块无缝集成到现有 Android 项目：

// build.gradle (Project level)
plugins {
    id 'com.android.application' version '8.9.0'
    id 'org.swift.android' version '1.0.0'  // Swift Android Gradle 插件
}

// build.gradle (Module level)
swift {
    // 配置 Swift 模块路径
    sources {
        include "../SwiftShared"
    }
    
    // 配置 Android SDK
    androidSdk {
        minApi = 24
        targetApi = 35
    }
    
    // 启用 Swift 并发模型
    features {
        concurrency = true
        strictConcurrency = "complete"
    }
}

这种集成方式允许：

• Swift 模块与 Kotlin/Java 代码并存
• 增量迁移现有项目中的性能关键模块
• 混合使用 Swift 和 Kotlin 编写 UI

二、C 互操作革命：@c 与 @implementation 属性

2.1 背景：Swift 与 C 的"爱恨情仇"

Swift 从诞生之初就强调与 C 的互操作性，因为：

• Apple 平台大量使用 C API（Core Foundation、POSIX、各种系统库）
• 许多跨平台库只有 C 接口
• 系统级编程必须与 C 打交道

但长期以来，Swift 调用 C 代码存在明显痛点：

痛点一：手动桥接头文件

// 需要 Bridging Header
// MyProject-Bridging-Header.h
#include "my_c_library.h"
#include "another_c_header.h"

这在跨平台项目中尤其麻烦——每个平台可能需要不同的桥接配置。

痛点二：Swift 代码暴露给 C 困难

传统方式需要：

1. 手动编写 C 头文件声明 Swift 函数
2. 使用 @_cdecl 导出
3. 处理类型映射（Swift 类型 ↔ C 类型）

// 传统方式：手动导出
@_cdecl("swift_function")
func swift_function_c_wrapper(_ x: Int32) -> Int32 {
    return Int32(swiftFunction(Int(x)))
}

// 还需要在头文件中手动声明
// void swift_function(int x);

痛点三：多模块同名 API 歧义

当两个 C 库都定义了同名函数时，Swift 无法直接区分。

2.2 @c 属性：自动生成 C 头文件

Swift 6.3 引入了 @c 属性，彻底改变了 Swift → C 的互操作体验。

基本用法

@c
public func calculateSum(_ a: Int32, _ b: Int32) -> Int32 {
    return a + b
}

@c
public func greet(name: UnsafePointer<CChar>) -> UnsafeMutablePointer<CChar>? {
    let swiftString = String(cString: name)
    let greeting = "Hello, \(swiftString)!"
    return strdup(greeting)
}

编译器自动生成对应的 C 头文件：

// Auto-generated header
#pragma once
#include <stdint.h>

int32_t calculateSum(int32_t a, int32_t b);
char* greet(const char* name);

枚举导出

@c
public enum ErrorCode: Int32 {
    case success = 0
    case invalidArgument = 1
    case outOfMemory = 2
    case internalError = 99
}

@c
public enum LogLevel: UInt8 {
    case debug = 0
    case info = 1
    case warning = 2
    case error = 3
}

生成：

typedef enum {
    ErrorCode_success = 0,
    ErrorCode_invalidArgument = 1,
    ErrorCode_outOfMemory = 2,
    ErrorCode_internalError = 99
} ErrorCode;

typedef enum {
    LogLevel_debug = 0,
    LogLevel_info = 1,
    LogLevel_warning = 2,
    LogLevel_error = 3
} LogLevel;

结构体导出

@c
public struct Point {
    public var x: Double
    public var y: Double
    
    public init(x: Double, y: Double) {
        self.x = x
        self.y = y
    }
}

@c
public struct Rectangle {
    public var origin: Point
    public var width: Double
    public var height: Double
}

生成：

typedef struct {
    double x;
    double y;
} Point;

typedef struct {
    Point origin;
    double width;
    double height;
} Rectangle;

2.3 @implementation 属性：为现有 C 声明提供 Swift 实现

@implementation 属性允许你为已有的 C 函数声明提供 Swift 实现。

// 假设有一个 C 头文件声明
// my_math.h
// int factorial(int n);
// int fibonacci(int n);

@c @implementation
public func factorial(_ n: CInt) -> CInt {
    guard n <= 1 else { return 1 }
    return n * factorial(n - 1)
}

@c @implementation
public func fibonacci(_ n: CInt) -> CInt {
    if n <= 1 { return n }
    
    var a: CInt = 0
    var b: CInt = 1
    for _ in 2...n {
        let temp = a + b
        a = b
        b = temp
    }
    return b
}

这样，Swift 代码可以直接替换 C 实现，而调用方完全无感知。

2.4 实战案例：用 Swift 重写 C 库核心算法

假设有一个性能关键的图像处理库，核心函数是高斯模糊：

// gaussian_blur.h
#pragma once
#include <stdint.h>

typedef struct {
    uint8_t r, g, b, a;
} Pixel;

void gaussian_blur(
    Pixel* input,
    Pixel* output,
    int width,
    int height,
    float sigma
);

传统 C 实现：

void gaussian_blur(Pixel* input, Pixel* output, int width, int height, float sigma) {
    // 传统 C 实现，约 200 行代码
    // 使用原始指针操作
    // 难以利用 SIMD 指令
    // ...
}

使用 Swift 6.3 重写：

// GaussianBlur.swift
import Accelerate  // macOS/iOS
import simd

@c @implementation
public func gaussian_blur(
    _ input: UnsafeMutablePointer<Pixel>,
    _ output: UnsafeMutablePointer<Pixel>,
    _ width: CInt,
    _ height: CInt,
    _ sigma: CFloat
) {
    let w = Int(width)
    let h = Int(height)
    let kernelSize = Int(sigma * 3 * 2) | 1  // 确保 奇数
    let kernelRadius = kernelSize / 2
    
    // 使用 Swift 的安全数组操作
    let pixels = UnsafeBufferPointer(start: input, count: w * h)
    var tempBuffer = [Pixel](repeating: Pixel(r: 0, g: 0, b: 0, a: 0), count: w * h)
    
    // 生成高斯核
    var kernel = [Float](repeating: 0, count: kernelSize)
    var sum: Float = 0
    for i in 0..<kernelSize {
        let x = Float(i - kernelRadius)
        kernel[i] = exp(-(x * x) / (2 * sigma * sigma))
        sum += kernel[i]
    }
    for i in 0..<kernelSize { kernel[i] /= sum }
    
    // 水平模糊（可使用 SIMD 加速）
    DispatchQueue.concurrentPerform(iterations: h) { y in
        for x in 0..<w {
            var r: Float = 0, g: Float = 0, b: Float = 0
            for k in 0..<kernelSize {
                let px = min(max(x + k - kernelRadius, 0), w - 1)
                let pixel = pixels[y * w + px]
                r += Float(pixel.r) * kernel[k]
                g += Float(pixel.g) * kernel[k]
                b += Float(pixel.b) * kernel[k]
            }
            tempBuffer[y * w + x] = Pixel(
                r: UInt8(min(max(r, 0), 255)),
                g: UInt8(min(max(g, 0), 255)),
                b: UInt8(min(max(b, 0), 255)),
                a: pixels[y * w + x].a
            )
        }
    }
    
    // 垂直模糊
    DispatchQueue.concurrentPerform(iterations: w) { x in
        for y in 0..<h {
            var r: Float = 0, g: Float = 0, b: Float = 0
            for k in 0..<kernelSize {
                let py = min(max(y + k - kernelRadius, 0), h - 1)
                let pixel = tempBuffer[py * w + x]
                r += Float(pixel.r) * kernel[k]
                g += Float(pixel.g) * kernel[k]
                b += Float(pixel.b) * kernel[k]
            }
            output[y * w + x] = Pixel(
                r: UInt8(min(max(r, 0), 255)),
                g: UInt8(min(max(g, 0), 255)),
                b: UInt8(min(max(b, 0), 255)),
                a: tempBuffer[y * w + x].a
            )
        }
    }
}

优势：

• 类型安全：Swift 的类型系统防止越界访问
• 并发安全：使用 GCD 并行处理，无需担心数据竞争（Swift 6 的 Sendable 检查）
• 可维护性：代码更清晰，易于理解
• 性能：Swift 编译器可以应用与 C 相同的优化

2.5 :: 模块选择器语法

Swift 6.3 引入了 C++ 风格的模块选择器语法，解决多模块同名 API 问题：

import ModuleA
import ModuleB

// 两个模块都有 getValue() 函数
// 传统方式：无法区分
// let x = getValue()  // 编译错误：歧义

// Swift 6.3：使用 :: 语法
let x = ModuleA::getValue()  // 调用 ModuleA 的版本
let y = ModuleB::getValue()  // 调用 ModuleB 的版本

这在以下场景特别有用：

• 链接多个版本的同一库
• 使用多个第三方库，它们可能定义了同名函数
• 渐进式迁移到新版本 API

三、嵌入式编程：Swift 进军 MCU 领域

3.1 为什么 Swift 适合嵌入式？

嵌入式开发传统上使用 C/C++，但 Swift 6.3 带来了独特优势：

3.2 Swift 嵌入式工具链

Swift 6.3 提供了完整的嵌入式开发支持：

# 安装嵌入式 SDK
$ swift sdk install armv7em-unknown-none-eabi

# 创建嵌入式项目
$ swift package init --type executable --name BlinkLED

# 交叉编译
$ swift build --sdk armv7em-unknown-none-eabi --configuration release

3.3 实战：STM32 LED 闪烁

// Sources/BlinkLED/main.swift
import STM32F4

@main
struct BlinkLED {
    static func main() async {
        // 初始化 GPIO
        let gpio = GPIO(port: .A, pin: 5)
        gpio.setMode(.output)
        gpio.setOutputType(.pushPull)
        gpio.setSpeed(.high)
        gpio.setPull(.none)
        
        // 主循环
        while true {
            gpio.toggle()
            await Task.sleep(for: .milliseconds(500))
        }
    }
}

3.4 嵌入式并发：Actor 模型

Swift 6 的 Actor 模型在嵌入式场景特别有价值：

// 传感器读取 Actor
actor SensorReader: Sendable {
    private var lastReading: Float = 0
    
    func readTemperature() async throws -> Float {
        // 模拟 I2C 读取
        let rawValue = try await I2C.read(device: 0x48, register: 0x00)
        let temperature = Float(rawValue) * 0.5 - 20.0
        lastReading = temperature
        return temperature
    }
    
    func getLastReading() -> Float {
        return lastReading
    }
}

// 主逻辑
@main
struct SensorApp {
    static let sensor = SensorReader()
    
    static func main() async {
        while true {
            do {
                let temp = try await sensor.readTemperature()
                print("Temperature: \(temp)°C")
            } catch {
                print("Sensor error: \(error)")
            }
            await Task.sleep(for: .seconds(1))
        }
    }
}

Actor 确保了对 lastReading 的安全并发访问，无需手动加锁。

3.5 内存管理：手动控制 ARC

嵌入式场景中，自动引用计数（ARC）可能引入不确定性。Swift 6.3 提供了手动控制能力：

// 禁用特定区域的 ARC
@noARC
func criticalSection() {
    let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: 256)
    // 手动管理内存，确保实时性
    defer { buffer.deallocate() }
    
    // 关键实时代码
    process(buffer)
}

四、构建系统统一：Swift Package Manager 重大升级

4.1 统一构建引擎

Swift 6.3 的 Swift Package Manager 集成了新的统一构建引擎，提供：

• 一致的跨平台构建体验
• 更快的增量构建
• 更好的依赖解析

// Package.swift - 声明式构建配置
let package = Package(
    name: "MyApp",
    platforms: [
        .iOS(.v18),
        .macOS(.v15),
        .android(.v24),  // 新增 Android 平台
        .embeddedArm()    // 新增嵌入式平台
    ],
    products: [
        .library(name: "MyLib", targets: ["MyLib"]),
        .executable(name: "MyCLI", targets: ["MyCLI"])
    ],
    targets: [
        .target(
            name: "MyLib",
            dependencies: [],
            swiftSettings: [
                .unsafeFlags(["-Osize"], .when(configuration: .release)),
                .enableFeature("StrictConcurrency")
            ]
        )
    ]
)

4.2 增量构建优化

新的构建引擎显著提升了增量构建性能：

五、性能控制：为库作者提供底层能力

Swift 6.3 为库作者提供了三个新的性能控制属性：

5.1 @specialize：特化泛型

public func sortArray<T: Comparable>(_ array: [T]) -> [T] {
    return array.sorted()
}

// 请求编译器为特定类型生成特化版本
@specialize(where T == Int)
@specialize(where T == Float)
@specialize(where T == String)
public func sortArray<T: Comparable>(_ array: [T]) -> [T] {
    return array.sorted()
}

编译器会为这些类型生成无泛型开销的特化版本。

5.2 @inline(__always)：强制内联

@inline(__always)
public func fastAbs(_ x: Int) -> Int {
    return x < 0 ? -x : x
}

适用于性能关键的小函数，确保零调用开销。

5.3 @export(implementation)：导出实现

@protocol
public protocol Drawable {
    func draw()
}

// 导出默认实现到子模块
@export(implementation)
extension Drawable where Self: UIView {
    func draw() {
        // 默认绘制逻辑
    }
}

六、weak let：并发安全的弱引用

Swift 6.3 解除了一个长期限制：weak 现在可以与 let 结合使用。

6.1 传统限制

// Swift 6.2 及之前：编译错误
// weak let parent: Parent? = nil  // 错误：weak 只能与 var 一起使用

原因：weak 引用可能在运行时变为 nil（当被引用对象被释放时），因此必须是可变的。

6.2 Swift 6.3 的解决方案

class Child: Sendable {
    // 并发安全：编译器自动处理 nil 检查
    weak let parent: Parent?
    
    init(parent: Parent?) {
        self.parent = parent
    }
    
    func doSomething() async {
        // 编译器自动处理 nil 情况
        await parent?.doWork()
    }
}

在并发上下文中，weak let 确保：

• 引用不可变（符合 Sendable 协议）
• 编译器自动插入 nil 检查
• 线程安全（编译器确保访问原子性）

七、迁移指南：从 Swift 6.2 升级到 6.3

7.1 兼容性评估

Swift 6.3 是一个高度兼容的版本，大部分代码无需修改即可编译。但以下情况需要注意：

潜在兼容性问题：

1. 使用了同名函数的多模块项目：需要显式使用 :: 语法消除歧义
2. 自定义 C 桥接逻辑：可能需要重构为使用 @c 属性
3. 依赖了旧的嵌入式 API：需要更新到新的 SDK

7.2 迁移步骤

# 1. 更新工具链
$ xcode-select --install  # macOS
$ swift --version        # 确认版本 >= 6.3

# 2. 更新 Package.swift
# 添加新平台支持（可选）
platforms: [
    .android(.v24),
    .embeddedArm()
]

# 3. 启用新特性（可选）
swiftSettings: [
    .enableFeature("StrictConcurrency", .when(configuration: .release))
]

# 4. 编译测试
$ swift build
$ swift test

7.3 利用新特性的渐进式迁移

阶段一：C 互操作优化

将手动桥接头文件替换为 @c 属性：

// Before: Bridging-Header.h
// #include "my_lib.h"

// After: 直接在 Swift 代码中标注
@c
public func mySwiftFunction() { ... }

阶段二：并发模型升级

将 weak var 更新为 weak let（如果适用）：

// Before
class MyClass {
    weak var delegate: MyDelegate?
}

// After
class MyClass: Sendable {
    weak let delegate: MyDelegate?
}

阶段三：跨平台扩展

添加 Android 和嵌入式目标：

// Package.swift
platforms: [
    .iOS(.v18),
    .macOS(.v15),
    .android(.v24),  // 新增
    .embeddedArm()    // 新增
]

八、生态展望：Swift 的 2026 与未来

8.1 跨平台版图扩张

Swift 6.3 标志着 Swift 正式进入：

• 移动端全平台：iOS、macOS、watchOS、tvOS、Android
• 服务端：Linux、Windows Server
• 嵌入式：ARM Cortex-M、RISC-V

这为"一次编写，多端运行"奠定了基础。

8.2 与其他语言的竞争格局

Swift 的独特优势在于：

• Apple 生态最佳体验
• 现代语言设计
• 跨平台能力快速增长

8.3 预测：Swift 7.0 的方向

基于 Swift 6.3 的演进，我们预测 Swift 7.0 可能带来：

• 完整的 ABI 稳定性：跨模块二进制兼容
• Windows SDK：官方 Windows 原生应用支持
• 更多嵌入式目标：ESP32、Arduino
• AI/ML 原生支持：类似于 Python 的 NumPy 生态

九、总结：Swift 6.3 的技术价值

Swift 6.3 的三大创新——Android SDK、C 互操作革命、嵌入式扩展——共同指向一个愿景：成为真正的通用编程语言。

对于开发者而言：

• iOS 开发者：可以更容易地扩展到 Android，分享业务逻辑代码
• 跨平台开发者：有了除 Kotlin Multiplatform 之外的新选择
• 嵌入式工程师：获得了更安全、更高效的开发工具
• 库作者：@c 属性极大简化了 C 桥接工作

Swift 正在从一个"Apple 平台专用语言"成长为"全栈编程语言"。2026年，是 Swift 跨平台的元年。

参考资料

1. Swift 6.3 Release Notes - swift.org
2. Swift Android SDK Documentation - developer.apple.com
3. Swift C Interoperability Guide - swift.org
4. Swift Embedded Programming - swift-embedded.github.io
5. Swift Package Manager 6.3 Documentation - github.com/apple/swift-package-manager