Swift toolchain is still a bit gross, you’ll need to use some temporary workarounds until Apple fixes it (see UPDATES below)

Here is a list of items that you can do to keep yourself from going crazy.

Slowness caused by immature Swift compiler

• Change your development workflow using Injection for Xcode. Once you installed the plugin, you’ll be able to inject code changes in your simulator\device without recompiling. You don’t need to hardcode\modify anything in your project. We started using it recently at work and it made a huge impact on our side, even if it doesn’t apply to every use case (for example you can’t create new functions, you can only modify the existing ones).

• Some particular code constructs that the compiler doesn’t like and takes too much time to compile. The most common problem is with the Type Checker that slows down compile time exponentially based on how many type checks it needs to do (read more here for practical examples and here for a detailed explanation). In order to identify if you are suffering from this problem you can follow this blog post, you will gather information about the functions that creates slowness by using some compiler additional flags. Alternatively you can use this Xcode plugin to identify the source of the build slowness.

• Use dynamic frameworks wisely, where it makes sense. A framework recompilation will be done only when you modify one of its Swift files (dynamic frameworks are only available for iOS >= 7).

• Condense code in the same files. Lowering the number of Swift files speeds up the compile process sensibly. You can easily achieve it enabling “Whole module optimization” by adding a user-defined custom flag SWIFT_WHOLE_MODULE_OPTIMIZATION and set it to YES and at the same time set optimization level to none (to disable optimizations that would make it slow) OUTDATED You may consider to use this gist, it’s a build script that collapses all your code in a “merge.swift” file.
  You’ll need to create a new target for it, but it is worth a
  try.

• Double check things listed here (there are a few some more misc reasons because the compilation is slow)

• OUTDATED Try the approach described in this blog post, it involves creating a build script that generates a make file. It requires manual intervention on the build script (it contains the list of swift files).

• OUTDATED Try this hacked up incremental compilation technique

UPDATE: Incremental builds introduced on Swift 1.2 (Xcode 6.3)

Apple finally introduced incremental builds with Swift 1.2 (shipped with Xcode 6.3). It’s not still perfect, but it’s a huge improvement.

From now on a class is recompiled only when it is changed (or when one of the class it depends on has been changed).
However the compiler still can’t understand if the changes to a class are to its interface or not. So any kind of change to a class causes a recompilation of that class and all of its dependencies.

UPDATE: Recompile dependent classes only when public interface changes introduced on Swift 2.1 (Xcode 7.1)

Starting from Swift 2.1 (Xcode 7.1), the dependent classes are recompiled only when you change the public interface of a class, and not at every change. This makes an huge difference in particular for big projects.

Project (mis)configuration (not related to Swift)

• Be sure that “Build Active Architecture Only” is YES for debug.
• Be sure that you didn’t add pre\post compilation scripts that take too much time.