What is Tuist?

Tuist is a command line tool written in Swift that helps you generate, maintain and interact with Xcode projects.

It focuses on simplicity and productivity. It has an elegant API that is natural to understand and use.

Our goal is to bring you focus and deal with intricacies for you. We believe many concepts that Xcode developers are exposed to nowadays are implementation details that they shouldn’t have to worry about. In most cases, understanding those details is not necessary to do the work, only if you need to introduce optimizations at the low level.

In the same way nowadays, a backend developer barely needs to know about SQL, or frontend developer about asset bundling, with Tuist, developers don’t need to know how to configure an Xcode project right or automate the most common tasks.

Much inspiration for Tuist came from this talk from DHH, where he talks about a concept, conceptual compression, on which Tuist is based.

Without Tuist
How the projects setup looks without Tuist
With Tuist
How the projects setup looks with Tuist

Defining your projects

With Tuist, projects are defined in a Project.swift, also known as manifest. The manifest format that abstracts you from the implementation details of Xcode projects. In your manifest you can define which targets your project has, which sources and resources belong to them, as well as the dependencies with targets in the same and other projects. The advantages of defining the projects in a manifest are:

  • It can catch misconfigurations and fail early. For example, if a target has an invalid dependency, it’ll let you know before you start compiling the app.
  • Since the manifest doesn’t include Xcode implementation details, it's more unlikely to have git conflicts related to projects.
  • It makes the configuration easier. The decision on how the project looks is on you. Tuist processes it and manages the complexity for you. One example of that complexity is setting up dependencies between targets.
The example below shows the format of a project manifest:

Interacting with them

Tuist leverages project generation to provide a simple and convenient set of commands, standard across all the projects. The commands infer most of the necessary information from your projects, requiring you to pass only the arguments that are strictly necessary.

Having a standard command line interface makes it easier to jump between projects since there’s an interaction language everyone in the team is familiar with.

tuist init --platform ios
tuist generate
tuist build
tuist test
tuist run
tuist release
  • Init: Bootstraps a new project. You can specify the platform and the type of project and it’ll generate all the necessary artifacts (Info.plist, AppDelegate, Project.swift, Playgrounds…)
  • Generate: Generates the Xcode workspace and projects to work on a particular project.
  • Build: Builds the project in the current directory. It supports all the arguments that xcodebuild supports. (Not available yet)
  • Test: Test the project in the current directory. It supports all the arguments that xcodebuild supports. (Not available yet)
  • Run: Runs the project. If the project needs a device to run on, it’ll prompt you to select one. (Not available yet)
  • Release: Builds and publishes your project on iTunes Connect. (Not available yet)

The list of actions will likely grow as we get feedback from you.

Why should I use it?

Here are some good situations when we think you should consider using Tuist:

  • Because my projects and workspaces are too complex and only a few people in the team know how to configure them.
  • Because there are so many people commiting to the project that a lot of time is spent solving git conflicts.
  • Because I have many similar automation scripts and files, and need some standarization.
  • Because I need reliability on the automation layer but I don't have resources to work on that domain.
  • Because I want to be able to run my apps executing a command on the terminal.
  • Because I want to understand the project structure at a glance without getting lost in a .pbxproj file.

How can I adopt it?

Considering adopting Tuist? You can introduce it incrementally in your projects.

📦 Generate your projects
Define a Project.swift for each of your projects and use Tuist to generate the Xcode projects. You can keep using your existing tools and scripts (CocoaPods, Carthage, Fastlane).
👩‍💻 Use the command line interface
Leverage the commands that Tuist offers and get rid of boilerplate automation scripts and files. Set up your CI pipelines to use them and onboard your team.
🚀 Build stunning apps
You won't have to worry about the intricacies of configuring projects and automation scripts anymore. Use the time that you saved to focus on coding your apps.

That's it! How tedious the process will be depends on how complex your projects are. Unfortunately, we can't generate the manifest files from your existing projects.

As you can see, Tuist doesn't force you to change your projects structure, or CI setup. If you regret the adoption of the tool, you can easily drop it.

Start using it

eval \"$(curl -sL https://bit.ly/2JWMfx8)\"
tuist init --platform ios --product application
tuist focus

An open source project ❤️

Tuist is planned and developed in the open and will remain like that forever. It’s part of an inclusive organization that welcomes anyone, regardless of its background or experience, making them feel part of the project since their first contribution. One can contribute not only with code, but reporting bugs, sharing ideas, participating in discussions. If you love our mission of empowering developers to build great apps for the world, and would like to contribute, there’s a place for you.

Tuist and its projects wouldn’t be possible without the time the following contributors devoted:

Go back to the top ↑