Google Summer of Code 2026

Swift participated in Google Summer of Code 2026 with three accepted projects, focused on DocC, Swift Concurrency and swift-syntax. Here are the accepted projects and the project ideas we offered that year. Browse the other years on the GSoC page.

Discussions from this year are tagged gsoc-2026 on the Swift forums.

Accepted projects

Projects accepted for Swift in Google Summer of Code 2026, as announced on the Swift forums.

Task and TaskGroup tracking for Swift Concurrency

Contributor: Ege Kaya

Mentors: Mike Ash, Alastair Houghton

Results: Task and TaskGroup tracking for Swift Concurrency

Qualified name lookup for swift-syntax

Contributor: Filip Sakellariou

Mentor: Pavel Yaskevich

Results: Qualified Name Lookup for swift-syntax

DocC language features in SourceKit-LSP

Contributor: Padmashree S S

Mentors: Prajwal Nadig, Matthew Bastien

Results: DocC Language Features in SourceKit-LSP

Project ideas

Re-implement property wrappers with macros

Project size: 350 hours

Estimated difficulty: Intermediate

Recommended skills

Description

Property wrappers feature is currently implemented purely within the compiler but with the addition of Swift Macros and init accessors it’s now possible to remove all ad-hoc code from the compiler and implement property wrappers by using existing features.

This work would remove a lot of property wrapper-specific code throughout the compiler - parsing, semantic analysis, SIL generation etc. which brings great benefits by facilitating code reuse, cleaning up the codebase and potentially fixing implementation corner cases. Macros and init accessors in their current state might not be sufficient to cover all of the property wrapper use scenarios, so the project is most likely going to require improving and expanding the aforementioned features as well.

Expected outcomes/benefits/deliverables

The outcome of this project is the complete removal of all property wrappers-specific code from the compiler. This benefits the Swift project in multiple areas - stability, testability and code health.

Potential mentors

Qualified name lookup for swift-syntax

Project size: 350 hours

Estimated difficulty: Intermediate

Recommended skills

Description

Qualified name lookup is the process by which a compiler resolves a reference A.f into a lookup for entities named f within A. In Swift, this can mean looking into the type A and all of its extensions, superclass, protocols, and so on to find visible members. The project involves building a new library to be integrated into the swift-syntax package that implements Swift’s qualified name lookup semantics, making it easy to build source tools that resolve names. The library will likely include a symbol table implementation that provides efficient lookup of a given name within a given type. It should also integrate with last year’s unqualified name lookup library project, to provide complete support for name lookup on Swift code processed with swift-syntax.

Expected outcomes/benefits/deliverables

Potential mentors

Task and TaskGroup tracking for Swift Concurrency

Project size: 160 hours

Estimated difficulty: Advanced

Recommended skills

Description

The Concurrency runtime presently does not provide a way to keep track of which Tasks and TaskGroups are executing. This information is especially useful for debugging programs that use Swift Concurrency; without it, it’s possible to end up in situations where no progress is being made but you cannot see which tasks are outstanding since none of them are actually executing on a thread (so they don’t show up in backtraces).

An easy solution might be to have a global linked list of Tasks and TaskGroups, but that would cause unnecessary synchronization (or, for atomics, contention) between threads, which is highly undesirable.

The goal of this project is to investigate data structures we might use to track Tasks and TaskGroups and to measure their overhead to make sure that it is acceptable. A stretch goal might be to implement the necessary support to provide a list of extant Tasks and TaskGroups in Swift’s on-crash backtraces, and to provide some Python macros for LLDB that can list Tasks and TaskGroups.

Expected outcome/benefits/deliverables

Potential mentors

WebAssembly Reference Types (externref) Support in Swift Compiler externref) Support in Swift Compiler section" href="#webassembly-reference-types-externrefsupport-in-swift-compiler">

Project size: 200-300 hours

Estimated difficulty: Advanced

Recommended skills

Description

Core WebAssembly supports primitive scalar and vector types, such as i32/i64/f32/f64, and v128. For bridging high-level types that have reference semantics, WebAssembly host environment usually maintains an ad-hoc table that maps indices in this table to references stored in it.

For example, to bridge a garbage-collected JavaScript value to WebAssembly, a naive implementation can allocate a JavaScript array that holds a reference to this value, while an index in this array is passed to Swift compiled to Wasm that it can operate on. While these ad-hoc tables are the primary means to interoperate with JavaScript from Swift, they’re not optimal from binary size and performance perspective.

Recent WebAssembly standard text defines a new built-in externref type that can be stored in built-in WebAssembly tables and passed around on WebAssembly stack. It can’t be stored in Wasm linear memory, which only supports basic numeric types, integer indices in the built-in table are used for that instead. To support this, LLVM represents externref as a pointer in a reserved address space, while Clang at a higher level represents this as a built-in __externref_t type lowered to LLVM pointer type in the reserved address space.

We’re looking for a prototype of an experimental feature in the Swift compiler that allows easier interoperability with C and C++ code that uses __externref_t values. As a stretch goal, Swift standard library should facilitate easier interop with host environments for WebAssembly embedding.

Expected outcome/benefits/deliverables

Potential mentors

DocC Language Features in SourceKit-LSP

Project size: 200 hours

Estimated difficulty: Intermediate

Recommended skills

Description

SourceKit-LSP has recently added DocC Live Preview support that can be used in editors such as VS Code. It allows users to view a real time side-by-side preview of their documentation directly in their editor.

Live preview could be further improved by providing language features such as go to definition as well as diagnostics for invalid/missing symbol names within DocC markdown and tutorial files. It would also be useful to have the links within the preview window take the user to the relevant symbol or documentation file within the code base.

Expected outcomes/benefits/deliverables

Potential mentors

Support SPM Templates in VS Code

Project size: 200 Hours

Estimated difficulty: Intermediate

Recommended skills

Description

Add first-class support for the new Swift Package Manager (SwiftPM) template system in the official Swift VS Code extension. To increase adoption of the feature and provide an intuitive experience for users, the VS Code extension should be updated to interface with the template system without requiring the user to leave the VS Code experience by falling back to the command line.

For more details on how templates work in SPM, please review the accepted proposal on the Swift forums.

Expected outcomes/benefits/deliverables

Potential mentors

SwiftPM System Executables for Enhanced Plugin User Experience

Project size: 200 hours

Estimated difficulty: Intermediate

Recommended skills

Description

SwiftPM is somewhat unique as a package manager because it supports marking dependencies on packages from foreign package managers, such as apt, yum, and homebrew. Today this is mainly used for libraries to be linked into SwiftPM products.

SwiftPM plugins can depend on executable tools, built from source, to help generate code and resources. If a tool cannot be built from source using SwiftPM then the plugin can invoke it using an absolute path. But, how will it know if the tool is present at that path? Also, how will the user be guided to install the package if it is missing?

The idea is to implement a system executable target, similar to system library targets where package names can be specified based on different package managers. Plugins can then depend on system executable targets so that warnings are emitted if the tool cannot be found on the path, along with the recommended remedy (e.g. “apt-get install foo”) for any build errors. Since package manager may place tools in different locations based on the platform, there would be a SwiftPM plugin API for a plugin to specify the tool name and then it can discover the full path location. Add in some popular language-specific package manager support to gain access to many more tools (e.g. npm, and pip).

Expected outcomes/benefits/deliverables

Potential mentors

Sysroot Support in Swift’s build-script for Cross-Compilation Targets build-script for Cross-Compilation Targets section" href="#sysroot-support-in-swifts-build-script-for-cross-compilation-targets">

Project size: 160 hours

Estimated difficulty: Intermediate

Recommended skills

Description

Extend Swift‘s build-script with an experimental flag which provides the path to the sysroot of the target triple used when cross-compiling core libraries (not the Swift toolchain). This enables cross-compilation targets with other sysroots. Wasm already uses a sysroot, the approach is to generalize the mechanism by splitting out the Swift core library builds into separate build products to be used for cross-compilation to other target platforms. This idea is narrowly limited in scope to cross-compilation of Swift core libraries, cross-compiled Swift toolchains handled by --cross-compile-hosts option are out of scope.

Expected outcomes/benefits/deliverables

Potential mentors

Improved documentation for command line tools

Project size: 175 hours (medium)

Estimated difficulty: Intermediate

Recommended skills

Description

Swift Argument Parser has a command plugin that generates documentation markup for a command line tool. This plugin could be improved by providing support for generating separate pages for each command and by leveraging additional markdown syntax to organize command line flags into sections and display possible values and default values.

Beyond the markdown output, this plugin could be further improved by generating a “symbol graph” that describe each command and its flags, options, and subcommands. By describing the commands’ structure, tools like Swift DocC can further customize the display of command line tool documentation, support links to individual flags, and allow developers to extend or override the documentation for individual flags in ways that isn’t overwritten when regenerating the documentation markup from the plugin. If time allows, prototype some enhancement to command line documentation in Swift DocC that leverage the information from the command symbol graph file.

Expected outcomes/benefits/deliverables

Potential mentors

Documentation coverage

Project size: 90 hours (small)

Estimated difficulty: Intermediate

Recommended skills

Description

Enhance Swift DocC’s experimental documentation coverage feature to write coverage metrics in a new extensible file format that other tools can read and display. Define a few types of metrics—for example Boolean (has documentation: true/false), Fraction (2/3 parameters are documented), Integer (page has 2 code examples), Percentage, etc.—for this format.

Explore ideas for what documentation coverage information would be useful to have and ideas for how another tool could present that information by prototyping a tool using your technology of choise. Iterativelt refine the documentation coverage file format based on what you learn from consuming and displaying this data in your protype tool.

Expected outcomes/benefits/deliverables

Potential mentors

Globally Scoped Traits for Swift Testing via runtime configuration schema

Project size: 80 hours

Estimated difficulty: Intermediate

Recommended skills

Description

Traits are a powerful tool for customising test functions and suites. For example, you can specify timeout and retry on a test case or suite basis. It would be especially useful to apply a trait globally. For example, users may want to run all tests with a specific timeout in CI.

As an initial foray into globally scoped traits, implement a configuration to set global traits at runtime for Swift Testing.

Expected outcomes/benefits/deliverables

Potential mentors