Swift Compiler Crash With Strict Concurrency

Jan 17, 2026 by Editorial Team 45 views

Hey guys, this article dives into a nasty bug encountered when using Swift's strict concurrency features. Specifically, we'll explore a crash that happens during the SendNonSendable SIL (Swift Intermediate Language) pass. If you're into concurrency and enjoy a bit of a challenge, or you just want to understand some of the nuances of Swift, then keep reading. We will walk through the problem, how to reproduce it, and the potential impact it can have on your projects. This kind of stuff is really important to know because it's the stuff that can really trip you up and make you waste a lot of time debugging.

The Problem: SendNonSendable SIL Pass Crash

So, what's the deal? The issue revolves around the SendNonSendable SIL pass, which is part of the compiler's strict concurrency checks. Basically, this pass is designed to ensure that data being shared between different threads or actors is safe. This means it makes sure that data is either Sendable (meaning it can be safely copied or moved between threads) or that appropriate synchronization mechanisms are in place. But in this case, the SendNonSendable pass crashes the compiler when strict concurrency is enabled. This is a big problem because it can block your build process, stop you from using newer concurrency features, and generally cause all kinds of headaches. It's like the compiler is having a meltdown before it can finish its job, making it impossible to check your code for concurrency issues.

Imagine you're trying to build a house, and the foundation crew just… quits mid-pour. That's kinda what it's like. You can’t finish the rest of the project until they get their act together.

Keywords: Strict Concurrency, Swift Compiler, SendNonSendable, Crash, SIL Pass, Concurrency Bugs.

Reproducing the Crash: A Step-by-Step Guide

Alright, let's get down to the nitty-gritty and see how we can make this crash happen ourselves. The code snippet provided in the original bug report gives us a solid starting point. The steps are pretty straightforward. First, you'll need the Xcode and Swift versions that are mentioned to make sure you get the same result. Then, you'll compile the code with strict concurrency enabled. Here's a quick rundown of the code and the commands:

The Code: The core of the issue lies in the interaction between thread creation (pthread_create) and the sayHello function. The sayHello function, in this case, isn't thread-safe, and that's where the problem kicks in. The code is designed to emit a diagnostic, but the compiler ends up crashing instead.
The Command: You'll use the swiftc command-line tool to compile the code. The key part is enabling the StrictConcurrency feature. This tells the compiler to apply more rigorous checks related to concurrency.
```
swiftc -enable-upcoming-feature StrictConcurrency -parse-as-library rafdiag.swift
```
The Result: When you run this command, instead of the expected diagnostic, the compiler crashes. You'll see a stack trace that indicates the crash occurred within the SendNonSendable SIL pass. This means the compiler's attempt to identify and report concurrency issues failed miserably.

This is a classic example of a compiler bug, it's not the fault of the code. The good news is that the community is usually pretty quick to jump in and fix this. The bad news is you might have to wait a little while, or even find a work around if you are blocked.

Keywords: Reproduce Crash, Swiftc, StrictConcurrency, pthread_create, Compiler Bug.

Deep Dive into the Code: Understanding the Root Cause

Let's break down the code that triggers the crash a bit more. The core problem here is how the code interacts with threads using pthread_create. Here's a more detailed view:

pthread_create: This function is a C-based function, that is used to create a new thread. Because it's a very low level API, it doesn't automatically integrate with Swift's memory management and concurrency features.
sayHello(): This function is a simple function that prints a message to the console. The issue arises because it is called from within the thread created using pthread_create and isn't thread-safe or marked as @Sendable.

static func sayHello() {
   print("Hello, I don't do much")
}

Strict Concurrency: When the strict concurrency checks are enabled, the compiler is supposed to ensure that only Sendable data is accessed across threads. The compiler does not know if the called function is thread safe.
The Crash: During the SendNonSendable SIL pass, the compiler detects the non-Sendable call within the thread. However, instead of reporting an error, it crashes. This shows the compiler's inability to gracefully handle the situation, which is not really a developer's fault.

This crash is a bug in the compiler. It means the compiler can't handle the situation and fails instead of giving a useful diagnostic or warning.

Keywords: pthread_create, Sendable, Strict Concurrency, SIL Pass, Compiler Bug, Thread Safety.

Expected Behavior vs. Actual Result: What Should Happen?

So, what should happen when we run this code, and how does it differ from the actual result? Let's clarify the expected behavior:

Expected Behavior: With strict concurrency enabled, the compiler should analyze the code and identify potential concurrency issues. In this case, it should detect that sayHello() is being called from a thread, and that it isn't thread-safe. As a result, the compiler should produce a warning or error message, pointing out the concurrency issue.
Actual Result: The compiler crashes during the SendNonSendable SIL pass. Instead of giving us a helpful message, the build process completely fails. This is a very disappointing result because it stops the developer from moving forward with their project.

This behavior is not ideal because it prevents developers from finding and fixing concurrency problems. A good compiler should provide a useful diagnostic. This should guide developers in the right direction to make their code safe.

Keywords: Expected Behavior, Compiler Diagnostics, Concurrency Errors, Strict Concurrency.

Environment and Context: The Technical Details

To understand this bug, it is important to know the environment it happens in. This includes the versions of the tools and operating systems that are involved. The environment includes the following:

Swift Version: The Swift compiler version is 6.2 (swiftlang-6.2.0.19.9 clang-1700.3.19.1). This version has the bug.
Xcode Version: The Xcode version is 26.0.1.
Target: The target is arm64-apple-macosx26.0.

Knowing this information helps pinpoint the exact conditions that cause the crash. It is important for developers who are trying to reproduce the problem. It is also important for the developers who are fixing the problem to know what environments are affected. This information gives a clear picture of the bug's context.

Keywords: Swift Version, Xcode Version, Target, arm64-apple-macosx26.0, Bug Context.

Impact and Mitigation: What Does This Mean for You?

Okay, so what does this mean for you, the developer? The primary impact of this crash is that it can halt your build process. If you rely on strict concurrency checks (and you should!), you won't be able to compile code that uses threads in this way. This could be a significant problem if your project uses threading. This includes: User Interface (UI) responsiveness, background tasks, and parallel processing. This bug can have major impact on: Performance, responsiveness, and stability.

Here are a few things you can do to mitigate the problem:

Avoid pthread_create: Try to use Swift's concurrency features (like async/await and actors) instead of pthread_create whenever possible. This will make your code more type-safe and more compatible with the compiler's concurrency checks.
Disable Strict Concurrency (as a temporary workaround): If you absolutely must use pthread_create, you could disable strict concurrency checks. But, be aware that this reduces the protection that strict concurrency provides.
Keep Your Swift Toolchain Updated: Make sure you are using the latest stable version of the Swift toolchain. Updates often include bug fixes, which may resolve this issue. Check for updates regularly to make sure the problem doesn't affect your development workflow.
Report the Bug: As mentioned in the original report, submit a bug report to Swift.org. Providing detailed information (the code, steps to reproduce, and environment details) helps the Swift team address and fix the bug quickly. The more reports, the higher the priority.

By following these steps, you can minimize the impact of the crash and keep your development workflow moving forward.

Keywords: Impact, Mitigation, pthread_create, Strict Concurrency, Swift Concurrency, Bug Report, Workarounds.

The Road Ahead: Future of Concurrency in Swift

Concurrency in Swift is still evolving. Swift is improving concurrency support with new features, and the community is working hard to improve its stability and functionality. The Swift team is working to address the crash described in this article. In the future, we can look forward to even better support for concurrency. This includes: improved diagnostics, enhanced safety features, and better integration with low-level threading primitives.

Here are a few things to keep an eye on:

Continued Refinement of Strict Concurrency: As Swift evolves, the strict concurrency features will become even more robust and accurate.
Improved Error Messages: The Swift team is working on making the compiler's error messages clearer and more helpful.
Better Integration with Low-Level APIs: Future Swift versions will likely offer better integration with low-level APIs such as pthread.

By staying up to date with the latest developments in Swift, developers will be able to write safer, more efficient, and more reliable concurrent code.