Skip to content
The Foundation Project, providing core utilities, internationalization, and OS independence
C Swift C++ Objective-C Python CMake Other
Branch: master
Clone or download
spevans Merge pull request #2691 from spevans/pr_remove_symbol_alias
Remove old alias _$S15SwiftFoundation19_NSCFConstantStringCN
Latest commit 34442a4 Feb 22, 2020
Type Name Latest commit message Commit time
Failed to load latest commit information.
CoreFoundation Remove old alias _$S15SwiftFoundation19_NSCFConstantStringCN Feb 22, 2020
DarwinCompatibilityTests.xcodeproj DarwinCompatibilityTests: Update after file tree reorganisation. Feb 22, 2020
DarwinCompatibilityTests DarwinCompatibilityTests: Update after file tree reorganisation. Feb 22, 2020
Docs Revert "Foundation: fix missing string terminator" Feb 19, 2020
Foundation.xcodeproj GenerateTestFixtures: Fix building on Xcode Feb 20, 2020
Foundation.xcworkspace Xcode 10: Update to recommended settings Jun 8, 2018
Sources Merge pull request #2676 from compnerd/corruption Feb 22, 2020
Tests Merge pull request #2687 from spevans/pr_sr_10512 Feb 22, 2020
bin testing tool should be executable Dec 22, 2015
bootstrap/x86_64-apple-darwin/usr/local/include Initial implementation of Foundation. Nov 16, 2015
cmake/modules [test] Split TestFoundation in smaller tests for CTest reporting. Jan 15, 2020
lib spelling corrections Apr 11, 2019
.gitignore git: ignore vscode data Apr 13, 2019
.mailmap Add mailmap for git history. Apr 17, 2018
CMakeLists.txt Restructure `GenerateTestFixtures` into `Tests/Tools/GenerateTestFixt… Feb 15, 2020 [gardening] Prefer macOS over OSX (#1500) Apr 2, 2018
LICENSE Initial implementation of Foundation. Nov 16, 2015 [NFC] Grammar: a URL, not an URL Jun 25, 2019
build-android DEPLOYMENT_TARGET_ANDROID -> TARGET_OS_ANDROID May 10, 2019 Initial implementation of FTP Protocol May 15, 2019
configure Require gold on linux and freebsd by default. Apr 20, 2018 build: Add scripts to build and test using Xcode Oct 23, 2019


The Foundation framework defines a base layer of functionality that is required for almost all applications. It provides primitive classes and introduces several paradigms that define functionality not provided by either the Objective-C runtime and language or Swift standard library and language.

It is designed with these goals in mind:

  • Provide a small set of basic utility classes.
  • Make software development easier by introducing consistent conventions.
  • Support internationalization and localization, to make software accessible to users around the world.
  • Provide a level of OS independence, to enhance portability.

There is more information on the Foundation framework here.

This project, swift-corelibs-foundation, provides an implementation of the Foundation API for platforms where there is no Objective-C runtime. On macOS, iOS, and other Apple platforms, apps should use the Foundation that comes with the operating system. Our goal is for the API in this project to match the OS-provided Foundation and abstract away the exact underlying platform as much as possible.

Common API

Our primary goal is to achieve implementation parity with Foundation on Apple platforms. This will help to enable the overall Swift goal of portability.

Therefore, we are not looking to make major API changes to the library that do not correspond with changes made to Foundation on Apple platforms. However, there are some areas where API changes are unavoidable. In these cases, documentation on the method will provide additional detail of the reason for the difference.

For more information on those APIs and the overall design of Foundation, please see our design document.

Current Status

See our status page for a detailed list of what features are currently implemented.

Using Foundation

Here is a simple main.swift file which uses Foundation. This guide assumes you have already installed a version of the latest Swift binary distribution.

import Foundation

// Make a URLComponents instance
let swifty = URLComponents(string: "")!

// Print something useful about the URL

// Output: ""

You will want to use the Swift Package Manager to build your Swift apps.

Working on Foundation

For information on how to build Foundation, please see Getting Started. If you would like, please consult our status page to see where you can make the biggest impact, and once you're ready to make changes of your own, check out our information on contributing.


Why include Foundation on Linux?

We believe that the Swift standard library should remain small and laser-focused on providing support for language primitives. The Foundation framework has the flexibility to include higher-level concepts and to build on top of the standard library, much in the same way that it builds upon the C standard library and Objective-C runtime on Darwin platforms.

Why include NSString, NSDictionary, NSArray, and NSSet? Aren't those already provided by the standard library?

There are several reasons why these types are useful in Swift as distinct types from the ones in the standard library:

  • They provide reference semantics instead of value semantics, which is a useful tool to have in the toolbox.
  • They can be subclassed to specialize behavior while maintaining the same interface for the client.
  • They exist in archives, and we wish to maintain as much forward and backward compatibility with persistence formats as is possible.
  • They are the backing for almost all Swift Array, Dictionary, and Set objects that you receive from frameworks implemented in Objective-C on Darwin platforms. This may be considered an implementation detail, but it leaks into client code in many ways. We want to provide them here so that your code will remain portable.

How do we decide if something belongs in the standard library or Foundation?

In general, the dividing line should be drawn in overlapping area of what people consider the language and what people consider to be a library feature.

For example, Optional is a type provided by the standard library. However, the compiler understands the concept to provide support for things like optional-chaining syntax. The compiler also has syntax for creating Arrays and Dictionaries.

On the other hand, the compiler has no built-in support for types like URL. URL also ties into more complex functionality like basic networking support. Therefore this type is more appropriate for Foundation.

Why not make the existing Objective-C implementation of Foundation open source?

Foundation on Darwin is written primarily in Objective-C, and the Objective-C runtime is not part of the Swift open source project. CoreFoundation, however, is a portable C library and does not require the Objective-C runtime. It contains much of the behavior that is exposed via the Foundation API. Therefore, it is used on all platforms including Linux.

How do I contribute?

We welcome contributions to Foundation! Please see the known issues page if you are looking for an area where we need help. We are also standing by on the mailing lists to answer questions about what is most important to do and what we will accept into the project.

You can’t perform that action at this time.