Making `simdutf` (C/C++) seamlessly interoperate with Swift

MahdiBM · January 4, 2026, 10:56am

I'm trying to make GitHub - simdutf/simdutf: Unicode routines (UTF8, UTF16, UTF32) and Base64: billions of characters per second using SSE2, AVX2, NEON, AVX-512, RISC-V Vector Extension, LoongArch64, POWER. Part of Node.js, WebKit/Safari, Ladybird, Chromium, Cloudflare Workers and Bun. seamlessly interoperate with Swift, and considering my insufficient knowledge of C/C++ and the fact that C++ interop is new, I need your help .

The related Pull Request is this one:

github.com/simdutf/simdutf

Make simdutf trivial to use in Swift, through Swift's C++ interoperability

master ← MahdiBM:mmbm-swiftpm-integration

opened 07:42AM - 04 Jan 26 UTC

MahdiBM

+38 -2

### Short title (summary): Enable seamless Swift interoperability with this p…ackage. ### Description Let's preface this with saying that I'm not a C++ developer, and I'll be happy to adjust the code based on your feedback or even nitpicks. The idea of making simdutf swift-compatible came from this [discussion in `apple/swift-nio`](https://github.com/apple/swift-nio/pull/3469#issuecomment-3705878406). This PR is to open up the discussion with a POC, and see if these changes are acceptable or not. If you prefer to have the discussion elsewhere, we can discuss this in that place, but I wanted to have something to show, and not just discuss theories. #### What I've done * Add `Package.swift` so SwiftPM can recognize and compile this library. * See [facebook/zstd](https://github.com/facebook/zstd/blob/dev/Package.swift) as prior art. * Add a modulemap, again for SwiftPM. To be verified if this is actually required or we can get rid of it. * As an example, modify `validate_utf16_as_ascii` so Swift can synthesize it via its `Span` types. * That means using these 2 attributes: `__counted_by(len)`, `__noescape` * `__counted_by(len)` declares that the amount of bytes in that pointer is declared by the variable `len`. * `__noescape` declared that the pointer will not outlive the function call. So Swift can deallocate it as it wishes. * Both are required for Swift to synthesize code using Swift `Span`s. * Without these 2 attributes, Swift will only synthesize code via `UnsafePointer` family of types and `len`, instead of a `Span`. #### What remains to be done in my view: * Perhaps guard `__counted_by` and `__noescape` behind some custom attributes where they are available at all? * Again, I'm not sure if this is actually needed. Not a C/C++ dev. * Add Swift tests to ensure Span compatibility. I can set up the CI as well. * We can only have Linux CI, or we can have both Linux and macOS. Depending on what you'd like. Optimally both. * I haven't tested this on Windows, but I can if required. It should work fine in theory. In any case it shouldn't be a blocker. * Ask around to see why Swift wasn't synthesizing Swift Span types from `std::span` when I was trying it earlier. * We'd still need to add `__noescape` attributes to `std::span` arguments, so it'll still require some changes. * I need to double-check if it's required to require Swift 6.2. * Perhaps we can require Swift 6 only, and on Swift 6.2 and above Swift can synthesize the `Span` versions of the functions as well. * `Span`s and C++ interop are new to Swift in Swift 6.2, which is the current latest minor version. * Docs update. #### Other notes When we're close to be done with this PR, I can ask some Apple folks to review the PR as well, considering C++ interoperability (unlike C) is new in Swift. They might not be able to directly comment in this PR/repository, but I can open up a discussion in Swift forums. Swift's ecosystem also tries to follow Sem Ver 2.0, which I think is the same thing that this library aims for. So we should be good on that front as well. ### Type of change - [ ] Bug fix - [ ] Optimization - [x] New feature - [ ] Refactor / cleanup - [ ] Documentation / tests - [ ] Other (please describe): ### How to verify / test Adding tests remains to be done. Watch this WWDC25 video for some info about C++ interoperability in Swift, if you're curious: https://developer.apple.com/videos/play/wwdc2025/311/ You can also just read the transcript and the 2 articles linked in "Resources". I'm currently testing these in a package of mine on macOS. [swift-idna](https://github.com/swift-dns/swift-idna) - branch `mmbm-simdutf` See the [branch's small diff](https://github.com/swift-dns/swift-idna/compare/main...mmbm-simdutf) compared to main. Build via `swift build`. If you don't have Swift installed, [install Swift 6.2.3 via `swiftly`](https://www.swift.org/install/linux/), or another way of your choice. If you'd like, open `swift-idna` in VSCode (or any of the forks) and install the [official Swift extension](https://open-vsx.org/extension/swiftlang/swift-vscode). I've yet to get things building on Linux, looks like there are some C++ interop issues there? I personally need to be able to use simdutf on Linux as well, so I'll get that working one way or another. ### Please read before contributing: - [x] CONTRIBUTING: https://github.com/simdutf/simdutf/blob/master/CONTRIBUTING.md If you can, we recommend running our tests with the sanitizers turned on. For non-Visual Studio users, it is as easy as doing: ```bash cmake -B build -D SIMDUTF_SANITIZE=ON cmake --build build ctest --test-dir build ``` Our CI checks, among other things, for trailing whitespace. Checklist before submitting - [ ] I added/updated tests covering my change (if applicable) - [x] Code builds locally and passes my check - [ ] Documentation / README updated if needed - [x] Commits are atomic and messages are clear - [ ] I linked the related issue (if applicable) Final notes - For large PRs, prefer smaller incremental PRs or request staged review. Thanks for the contribution!

I also tried to look around in apple / swiftlang orgs to find some examples of C++ Span interop, with no luck.
I'll be happy if you know and let me know of some good-quality projects that are similar to this situation, so I can take a look at them.

The maintainer is rightfully asking some questions, and I myself also have some questions:

1. Is a modulemap required for things to work, or can I reasonably get rid of it?
- The maintainer is fine with the modulemap so I'd just let it be if it's too problematic to remove.
1. Swift wasn't synthesizing Swift Span types from std::span even after the __noescape attributes I applied. Are there known issues/quirks around this?
- The library guards the Span support behind SIMDUTF_SPAN and claims it'll be enabled if on C++ 20, and I have also declared cxxLanguageStandard: .gnucxx20 in my Package.swifts.
- Could it be some kind of issue with the library correctly detecting and enabling its Span support? The related code is here.
1. Is it required to use Swift 6.2?
- Optimally we can have Swift synthesize function using Span on Swift 6.2, and for Swift 6.1 and 6.0 it can just only synthesize the functions via the UnsafePointer types.
1. How is the Package.swift file that I put together looking?
- Any issues/sub-optimalities there?

The following questions from a maintainer of the library are viewable in the PR as well:

1. The maintainer asks (link):
- Would it be implementable by adding a SIMDUTF_COUNTED_BY() macro that expands to the needed attributes?

The maintainer asks (link):
- Can this be solved in an easier way by instead providing a separate auto generated header file, where you can use all the attributes and swift specific code you wish?
- I think not? Because like in the WWDC 2025 video C++ interop, we need source file changes as well, other than header files changes?

1. About #include <lifetimebound.h>, the maintainer says (link):
- this is not a standard header, where is it defined? I can find it on my system using clang 21 and gcc 15.
- I suspect he meant to write "I can_'t_ find it on my system".
1. The maintainer asks (link):

looks like the __noescape could be expressed as a C++ attribute instead, can you use that instead?
Attributes in Clang — Clang 22.0.0git documentation

would that be useful outside of swift compatibility?

regarding the __counted_by, the only info I can find is that it is used on struct members. the gcc manual https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc.pdf says:

In C++ this attribute is ignored

are there alternative ways of specifying the "counted by" property?

I realize these might be one too many questions. I still appreciate any answers to any of them.

0xTim · January 4, 2026, 11:07pm

MahdiBM:

Is a modulemap required for things to work, or can I reasonably get rid of it?

The maintainer is fine with the modulemap so I'd just let it be if it's too problematic to remove.

Swift wasn't synthesizing Swift Span types from std::span even after the __noescape attributes I applied. Are there known issues/quirks around this?

The library guards the Span support behind SIMDUTF_SPAN and claims it'll be enabled if on C++ 20, and I have also declared cxxLanguageStandard: .gnucxx20 in my Package.swifts.

Could it be some kind of issue with the library correctly detecting and enabling its Span support? The related code is here.

Is it required to use Swift 6.2?

Optimally we can have Swift synthesize function using Span on Swift 6.2, and for Swift 6.1 and 6.0 it can just only synthesize the functions via the UnsafePointer types.

How is the Package.swift file that I put together looking?

Any issues/sub-optimalities there?

You don’t need a module map if the header files are in the right format/location that SwiftPM expects (so SwiftPM will synthesise one for you) but usually for adding Swift to existing projects it’s just easier to add a module map rather than reorganising the whole project.
Span types only work with lifetime and bounds annotations that line up with the expected types. You also need the right imports and features enabled. So it can be a bit tricky to make it all work. I don’t know the C++ 20 limitations but did you try with .cxx20 instead?
You need 6.2 to make it work, but it’s not a requirement to have the annotations I don't think. The new C imports might be problematic however. You need at least
```
.enableExperimentalFeature("SafeInteropWrappers"),

.unsafeFlags(["-Xcc", "-fexperimental-bounds-safety-attributes"]),
```
You might also want to include:
.strictMemorySafety()
at the package level and then
```
cSettings: [.define("ENABLE_C_BOUNDS_SAFETY")]
```
at the C level
I don’t know enough about C++ macros to say, but if the generated code is the same it should work fine
A separate header file will work (you can point to that in the module map) but then the maintainer has the issue of having to maintain 2
You don’t need source code changes for most stuff (unless you enable bounds safety in your C code) so that should be ok
It’s in {toolchain location}/usr/lib/clang/21/include/ so not available if not running from Swift
I believe __counted_by is the only way to make this work currently. AFAIK it’s a Swift/Clang concept, so not generally applicable. The no escape stuff should be pretty general as seen by add lifetime and no escape macros by lemire · Pull Request #896 · simdutf/simdutf · GitHub

Given the project is used by WebKit and WebKit has started to add these kind of annotations they may want to offer some advice/help out with this since it benefits them as well

MahdiBM · January 5, 2026, 11:52am

So I'm now trying again to get Span-synthesis work from std::span with no luck.

What I've tried / done:

Read compiler tests and ensure the all relevant flags such as SafeInteropWrappers or c++20, experimental feature are available in the SwiftPM build output.
Span-synthesis from pointers marked with __counted_by and __noescape does work.
Import the world in case an import is missing. Such as lifetimebound.h, ptrcheck, etc...

Some of the stuff I have in my Package.swift:

//swift-tools-version: 6.2

...

cxxLanguageStandard: .cxx20

...

var settings: [SwiftSetting] {
    [
        .swiftLanguageMode(.v6),

        .interoperabilityMode(.Cxx),
        .enableExperimentalFeature("SafeInteropWrappers"),
        .unsafeFlags(["-Xcc", "-fexperimental-bounds-safety-attributes"]),
        .strictMemorySafety(),
        .enableExperimentalFeature("LifetimeDependence"),

        .enableUpcomingFeature("MemberImportVisibility"),
        .enableUpcomingFeature("InternalImportsByDefault"),
        .enableUpcomingFeature("ExistentialAny"),
        .enableExperimentalFeature("Lifetimes"),
        .enableExperimentalFeature(
            "AvailabilityMacro=swiftIDNAApplePlatforms 26:macOS 26, iOS 26, tvOS 26, watchOS 26, visionOS 26"
        ),
        .enableExperimentalFeature(
            "AvailabilityMacro=swiftIDNAApplePlatforms 11:macOS 11, iOS 14, tvOS 14, watchOS 7"
        ),
        .enableExperimentalFeature(
            "AvailabilityMacro=swiftIDNAApplePlatforms 10.15:macOS 10.15, iOS 13, tvOS 13, watchOS 6"
        ),
    ]
}

The C++ library's Package.swift:

// swift-tools-version:6.2
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "simdutf",
    products: [
        .library(
            name: "simdutf",
            targets: ["simdutf"]
        )
    ],
    targets: [
        .target(
            name: "simdutf",
            path: ".",
            sources: [
                "src/simdutf.cpp"
            ],
            publicHeadersPath: "include",
            cxxSettings: [
                .headerSearchPath("src"),
                .headerSearchPath("include"),
            ]
        )
    ],
    cxxLanguageStandard: .cxx20
)

Any compilers engineer have any ideas what is going wrong here?

MahdiBM · January 6, 2026, 6:15am

Sorry @Douglas_Gregor for the ping, could you or one of your colleagues who work on C++ interop take a look?

TL;DR, I'm struggling to make Swift synthesize Span from std::span<...> __noescape.

This all should be reproducible for you as well. What I'd do to reproduce:

1. Clone swift-idna:
- https://github.com/swift-dns/swift-idna
- branch: mmbm-simdutf
1. Clone my fork of simdutf:
- https://github.com/MahdiBM/simdutf
- branch: mmbm-swift-take-2
1. In swift-idna's Package.swift (or via swift package edit) edit:
- .package(url: "https://github.com/mahdibm/simdutf.git", branch: "mmbm-swiftpm-integration"),
- To .package(path: "../simdutf"), or another valid path to the cloned simdutf.
- Just so you can mess around with simdutf later if you want, to get things working.
1. Open Sources/SwiftIDNA/+Span.swift, at the top of the file is an example of using simdutf.
1. Observe Swift doesn't accept passing an Span<UInt16> as a std::span<const char16_t> __noescape.

As a reminder from the previous post: