Pedro Piñera Builder and open-sourcerer. Tuist CEO and co-founder.

Tags

Tuist

Agentic productivity

We have the data from builds and test runs. We have the agent primitives in Elixir. Now we are connecting them into something that can actively improve your developer workflows, not just report on them.

Scoping dev environments to clones

When your team works with multiple clones of the same repository, global resources like ports and databases start to conflict. Here is how we solved it at Tuist using mise and a simple random suffix.

The tolerance shift

Coding agents are making developers and organizations less tolerant of slow toolchains. That shift in tolerance is opening a door that was surprisingly hard to open before.

The beauty of being open

Openness is not a trend or a distribution strategy. It's a way of building trust, expanding your pool of ideas, and creating something that lasts.

The obsession gap

A bet that obsession matters more than speed. That personality matters more than feature parity. That going deep matters more than going wide.

Building the house from the roof

Tuist started at the toolchain layer and is working its way down to compute and caching. This is the whole house, from roof to foundation, and why going deep into each layer is how you earn trust that money cannot buy.

The builder trap

Developers who build companies tend to fall in love with their creations. That love is a strength, but it can also become a blind spot when others see your work as an asset to acquire rather than a craft to respect.

The cache is the infrastructure

Why the future of CI isn't about dedicated compute but about colocated caching, and how build systems, coding agents, and shifting economics are making that future real.

The rhythm of building

Building a long-term company in dev tooling means accepting that some things can't be rushed. Ideas have their own pace, trust takes time, and not every shortcut is worth taking.

The Software Industry's inflection point

Reflections on how AI is reshaping code production, why companies must rethink where value lives, and what independence means in a world of accelerating change.

The normalization of unproductive environments

One of the biggest challenges we face at Tuist is that teams have normalized working without data. They stack decisions that erode productivity, then throw resources at the symptoms rather than understanding the cause.

Namespace gets macOS environment DX right

After years of painful Mac mini management for CI, we discovered Namespace - an API-first service that makes macOS environments elastic and developer-friendly. Perfect for building Tuist QA and beyond.

The coming disruption of Apple developer tooling

GitHub Actions and commoditized Mac infrastructure providers like Namespace are disrupting the stagnant Apple developer tooling market, enabling innovative alternatives to traditional pipeline-centric CI solutions.

The missing commoditization

I talk about the lack of innovation in the Apple ecosystem and how Tuist is reimagining developer experiences.

Tuist is evolving

In this blog post I talk about how Tuist is evolving and how some mental models are transitioning.

Small but sexy

The tech industry is obsessed with hyper-growth, but at Tuist, we prioritize quality over quantity. We are committed to building a product that sparks joy, investing in design, and embracing simplicity. Our focus on standards and open-source contributions drives our long-term growth.

The missing narrow waist in CI

It’s time for innovation to happen in the CI space through the narrow waist that Dagger brings to the table.

Meeting developers where they are

In this blog post I reflect on why I believe not more organizations are adopting Bazel and why Tuist is taking a different approach.

The non-technological open source problem

Open-source sustainability is hard, and while it’s necessary to have the tools to reward and pay contributors for their work, the problem requires more of us, developers, speaking out loud about the importance of contributing to the software that we depend on.

Incremental Xcode workflows across environments

Xcode struggles to achieve incremental builds within the same environment. What about across environments? Not even close. Tuist is working on bringing incremental builds and test execution to Xcode projects across environments.

XCBundles

Xcode doesn't have a native container for bundling resources for different platforms and architectures. But nothing stops us from creating our own for Tuist.

Starting therapy next week

2023 was a year of many challenges in my life. Next week I'm going to start mental therapy with a psychologist.

Implicitness in Xcode and SPM. Why Apple?

Apple embraced implicitness in some areas of the build system, and it's causing headaches to developers. In this post, I share my thoughts on the topic and how we are planning to address it in Tuist.

Ensuring a smooth workshop experience

In preparation for a workshop that I'm conducting in Swiftable (Buenos Aires), I came up with an idea to ensure a smooth experience following the workshop

Balancing mastery and sustainability

Juggling roles in Tuist, from coding to community support, taught the delicate balance between mastery and sustainability in open-source projects.

Dear Bitrise

Read my personal take on Bitrise's actions against Tuist, and how we're rallying as a community to uphold our values and vision.

From side project to sustainable tool

Tuist, now 6 years old, has become essential for organizations using Xcode. While initially a side project, its popularity surged. To ensure sustainability, we're introducing paid features alongside free ones, navigating challenges like unauthorized forks and finding the right business model.

Empowering Development: The Journey and Vision of Tuist

Tuist provides solutions to challenges in large-scale app development overlooked by Apple. It's a foundation for developers, promising simplicity and a future filled with actionable insights.

We do it for the community

Embarking on a nuanced journey with Tuist, facing ethical dilemmas & aiming for sustainability, I invite you to be part of our personal tech story.

Focused Xcode projects

A while ago, and inspired by Facebook's internal tooling, we added a new command to Tuist, tuist focus . As it names says, it's intended to be used when you want to work on a given target. If you have a project of, let's say 300 targets, yo…

Tuist 2.0 and next

As we are approaching the release of Tuist 2.0, I started thinking what's next for the project. The focus until 1.0 was around project generation. We provided developers with a graph-based project generation that abstracts away Xcode's intr…

The role of flexibility in scaling up Xcode projects

I often wonder why Apple continues to build features that are closed into Xcode, for example Swift Package Manager's integration. While some developers might see that as something positive, because that means it can be seamlessly integrated…

Open source, people, and happiness

When looked from the consumer standpoint, open source often reads as software publicly available that I can check out, use, and improve. However, there’s more than that. In a world where everyone seems to be obsessed with building the next…

Data-driven open source

Yesterday, we announced that Tuist has now stats that allows us to understand how users use the tool and therefore, invest our time working on Tuist more wisely. As expected, there were some negative reactions to this: Oh! I’m glad that I c…

Building Tuist as a platform

Having seen Shopify acting as an e-commerce platform that developers can extend made me think whether the same idea would be applicable to Tuist. What if instead of us trying to codify all different workflows and configurations, we gave dev…

Tuist and JS bundlers

I think there are a lot of similarities between Tuist and JS bundlers. First, they both are functions that take input and return an output. In the case of a JS bundler, it takes Javascript or any variation of it, and converts it into Javasc…

Focusing on the problems

One of the things that I noticed when building tools for developers, either through Tuist or my work at Shopify, is that we developers tend to get incredibly excited about what our new idea would enable, and put the need or problem aside. I…

Tuist and the Swift Package Manager

It's common to see developers wondering why they should use Tuist instead of the Swift Package Manager (SPM) for modeling their projects. I think it's normal. It happened to me a few times too. Some of them even made me wonder if I should c…

Tackling technical debt in Tuist

I've recently spent a lot of time in Tuist tackling technical debt. It'd been a while since the last time I have to pause some other work for weeks to do something that would be beneficial for the long-term of the project. This time the wor…

Decision records

One of the things I've been terrible at is at keeping decisions records in projects . It happens often working on Tuist that I come across something that I need to know why it was done in a particular way and I can't remember. It also happe…

Scaling up an open-source project

One thing that I've been struggling a lot with lately is the amount of distractions that come with the growth of an open-source project. In the case of Tuist , those distractions have come in the shape of notifications on GitHub, mentions o…

Sparking joy working with Xcode

I learned by working with Ruby and Ruby on Rails during my time at Shopify that using tools and programming languages that spark joy is crucial for developers' motivation. Even though we developers love to understand complexities, we enjoy…

Tree-shaking Xcode projects

Tree-shaking is a concept inspired by Javascript and used by Tuist to generate lean Xcode projects that are processed and compile faster.

Module caching in Xcode projects

Bazel and Buck is the solution large companies have adopted to make Xcode build fast. However, it's complex and not accessible to medium and small companies. In this blog post, I share the approach Tuist is taking and how it's inspired by tools the community is already using.

Growing Tuist's community

In this blog post, I share my experience building the Tuist community. I talked about the things that have worked well, and the areas where there's still some room for improvement.

Modularization in open source projects

I recently came across a blog post from Shopify where they share how they are componentize the main Rails application into smaller pieces with clearly defined boundaries and loose coupling between them. This made me think about the uFeature…

Pairing sessions to introduce people to Tuist and open-source

I recently started having pairing sessions with developers interested in contributing to open-source; it’s something that usually intimidates people, but that becomes easier if someone guides you through the first contribution. You have a p…

My first coding video on Youtube

I never thought I'd end up doing this, but today I just recorded an uploaded a video to Youtube that is meant to be the first of a series about Tuist . I recorded myself with Photo Booth, the screen and the voice using Quicktime, and edited…

To build, or not to build

These days I'm a rollercoaster of emotions ― I guess as a result of COVID19 and spending so much time at home. In particular, these days I'm thinking a lot about Tuist and my devotion for it. I really like building it, working on building s…

A better signing experience in Xcode

A few days ago, Marek decided to take on a proposal that I made for Tuist a while ago, management of certificates and provisioning profiles . As it happened with the definition of dependencies, dealing with certificates and provisioning pro…

From iOS engineer to a T-profiled techie

One of the things that excited me the most about the opportunity to join Shopify back in 2018 was the opportunity to grow and learn from the challenges and the talent of the company. When I joined, my background was mainly iOS development w…

Generation of Swift interfaces to access resources

Many of you might already be familiar with SwiftGen ; a tool that generates Swift code to access resources in a type-safe manner. Having a type-safe API is something that Android developers have had for a long time, and that Apple has never…

A standard CLI for Xcode projects

There’s an idea that I’d love Tuist to move towards: provide a CLI that is standard across all the projects defined using Tuist. This is not a new idea; we can see it in frameworks like Rails that thanks to being opinionated about the struc…

Evolving Tuist's architecture

I'm flying back from Tokyo and took the opportunity to code a bit on Tuist. Since I don't have Internet connection to get distracted with, I decided to work on something that doesn't require Internet connection: improving the project archit…

Seeking inmutability

I recently opened up this PR on Tuist that turns models that represent the projects into structs. For some reason, which I don't remember, I had the not-so-brilliant idea of defining them as classes. While that has been working fine, they d…

Working on a new website for Tuist

An update on what I'm up to these days with Tuist. In particular, I talk about the new website that I'm designing and implementing for the project.

Creating experiences

Picked up my phone and dumped some thoughts on why I'm so engaged and excited to build Tuist.

Better relative paths

We are providing a new API from Tuist to define relative paths and this blog post describes the motivation behind it and the solution that we are adopting.

Project description helpers

In this blog post I talk about a beautiful abstraction which Alex and I came up with to push Tuist's awesomeness even further.

Abstractions

In this blog post I talk about abstractions in the Xcode projects domain and how Tuist leverages the concept to conceptually compress intricacies of Xcode projects that developers are often confronted with.

What's coming to Tuist

A Monday blog post with some reflections about the current state of Tuist and its future.

Project generation

This blog post describes the advantages of dynamic over static Xcode projects, and how Tuist leverages project generation to help teams overcome the challenges associated to scaling up projects.

Adding error tracking to a CLI written in Swift

Trying to add error tracking to Tuist, I realized how the process is not very straightforward. This blog post describes the process that I followed to help other Swift developers add error tracking to their CLI tools.

Derived Info.plist files

In this mini-post I talk about some recent work that I've done in Tuist to support defining Info.plist files in the manifest file.

Open source and trust

Trust is key for open source projects to thrive. In this blog post I explain what trust has meant for Tuist.

Open source mindfulness

Not being mindful when contributing and maintaining open source projects might lead to burnout or low self-steem. In this blog post I talk about some principles that I applied to have a healthier relationship with the open source.