TCA showcase

[shahzadmajeed]

Hello,

One of the data point we are missing during TCA evaluation is existing apps that are built with TCA so we can try them out and see their complexity and user experience. This will make us more confident about using TCA for our future and current (long term large scale) apps.

TCA Authors: Do we have such a list?
Developers: If you have built apps with TCA and can include the name and link to App Store in the discussion below that would be greatly appreciated

Thank you

[saroar]

here is my own two app you can
https://github.com/AddaMeSPB/AddaMeIOS -> https://apps.apple.com/app/id1538487173
https://apps.apple.com/us/app/word300/id1619504857

[shahzadmajeed]

Thank you for sharing these

[josephktcheung]

I've scanned through Github and here's a list of open sourced apps that uses TCA:

Puffery App store: https://apps.apple.com/de/app/puffery/id1508776889
reminders-app
Marconio
Prose macOS
DroidKaigi 2021 iOS Application
weg-li
Seed
runitz
Critical Maps iOS App iTunes: https://itunes.apple.com/app/critical-maps/id918669647
GuitarTuner
Tube service App store: https://apps.apple.com/app/id1540626286#?platform=iphone

[shahzadmajeed]

Thank you for this list ❤️

[pacu]

Our App is still in the making but it's SwiftUI + TCA.

https://github.com/zcash/secant-ios-wallet

I've developed one of the first SwiftUI apps in the crypto space back in 2019 when SwiftUI was a mere beta. I can tell you that Vanilla Swift UI doesn't work for not even for "the Fruta App" applications. You need more tools. TCA is not a silver bullet but a very flexible tool that provides a framework that a team can use to build an application that uses unidirectional data driven flow to drive SwiftUI's DSL.

My main concern when evaluating TCA for building secant, was the learning curve. If your project is a fully open, everyone can contribute freely kind of project, TCA could be either: 1) a very attractive honey pot to get developers the TCA crave they were seeking, or 2) a contributor barrier. Only time will tell, currently is a coin-toss. If your project is closed-source and 9-to-5 coding. Your team will be very happy of learning new stuff. Every new hire of the future will benefit of having a clear onboarding route already created for you by the pointfree dudes.

What I can say about my experience so far:

The CONs:

• TCA has a learning curve proper of using a new paradigm with familiar tools. Takeaway: you will have this learning curve whatever your choice is if you are not familiar with it.
• You will have to create wrappers for dependencies you once used innocently "out-of-the-box". Takeaway: this was probably an illusion. You are paying the cost up front and before you were deferring it until it blew up on your face.
• Not the Drag and Drop solution you dreamed of.

The PROs:

• it's is very well documented. But, you have to make the time for reading it and sink it in. Unless you already know the functional paradigm, there are things than won't be easy so figure out just by cmd+click and reading the code.
• it provides a very opinionated way of handling state and data flow on your app. This reduces SwiftUI's bugs significantly. SwiftUI makes it easy to couple screens to one another. Combine observers can drag down your app's performance due to unexpected re-renders and hierarchy recreations that will make your app flicker, reset at best if not crash.
• it makes you have testable code by default. Having to wrap your dependencies in witnesses or wrappers lets you mock them you will have .live and .demo implementations of every dependency you once used to struggle with. Your app is far closer to 100% test coverage than ever before.
• it makes you a better developer. There's no way you go though the docs without learning something new.
• using Store and Reducer make your business logic fully unit-testable.

other comments:
You will compensate the learning curve with time saved by not having to deal with bugs caused by mishandled bindings, random re-renders, etc.

How I approached it:

The way I found to approaching TCA is actually subscribing to pointfree.co content and study it. Try to rely on people that has experience on it to help your team gain traction and experience. If not, create study groups and dedicate time of your day into absorbing the content generated by the authors. You won't be able to absorbe more than 45 minutes of content a day. Since there are many concepts that are covered throughout the episodes and in the end the only way to learn them fully is to apply them. If you have an urge, try to find contractors that are very familiar with it and let them help you ease the curve.

[jshier]

• TCA has a learning curve proper of using a new paradigm with familiar tools. Takeaway: you will have this learning curve whatever your choice is if you are not familiar with it.

I've found this learning curve always exists, even if you write your own app architecture from scratch. It's just that, by writing the architecture from scratch, you're learning the architecture while writing it, which will likely take more time overall than simply learning an architecture. If you take external contributions, contributors always have to ramp up on the architecture. At least with TCA there's extensive documentation, videos, and others using it, rather than none of those things for a bespoke solution.

[pacu]

Plus, there's a big chance that writing your own architecture goes wrong and you end up (luckily) re-inventing the wheel. If you have good fortune our wheel will turn without squiggling much.

[stephencelis]

@pacu Thanks for the feedback! We hope that some of the updates we have planned will help with some of the learning curve. We should probably get a proper "beta" channel for TCA going so folks can play with some of these planned features a bit earlier so that they can provide feedback. We do a lot of prolonged testing and refinement before releasing new features to TCA, but the more folks that have hands on it the better. Would you be interested in such a channel?

[shahzadmajeed]

Hi,

Thank you for sharing your input. I love this discussion. I cannot share exact details of our assessment right now but here are some points:

TCA

• ~30-40% of TCA code was needed to build features (local store, state and environment). We didn't want to use it for everything i.e., single store and pullback etc..
• Explicit thread safety is needed to avoid dirty reads & crashes i.e., all store.send calls should be on same thread (main)
• Learning curve was higher but I 💯 agree that learning curve is involved with every new architecture/pattern
• Testability is amazing with TCA, specially being able to test your logic with just a mock function (effect) was mind blowing
• There were lot of other factors considered which I'm skipping

Conclusion:
We will write our own lightweight (~200 LOC) state machine with some Combine extensions and use that within a home-written VIPER stack. This will allow us to extend our architecture to meet our uses cases/needs.

[gonzalonunez]

We're big fans of TCA at @withprimer :)

There is definitely a learning curve for new engineers, but the pros far outshine the cons:

• Testability is unlike any other iOS app architecture I've ever seen, the cost of writing and maintaining good tests is extremely low
• It increases the ease with which you can interop between SwiftUI and UIKit (passing Stores around is simple) which has been really nice for us
• It's fun to use and write code with! There is a fair amount of boilerplate for new features but these are solvable problems with increasingly mature tooling

You can download the Primer app here. We also have a second smaller app, Zines, that is also built with TCA (and free to use, so it's probably more useful to check out).

[shahzadmajeed]

Interop is an interesting point and I didn't think if it before. I can definitely see how TCA can help with that. Did you face any issue with thread safety?

[gonzalonunez]

No! At least none that I'm aware of and we monitor our errors well. For what it's worth, we do very basic multithreading, nothing crazy.

[ZevEisenberg]

We're using TCA in the new how-to app for kids at The New York Times. We're loving the increased testability it affords.

[shahzadmajeed]

Thank you for your input. Which architecture do you use for main apps at NYTimes?

[shahzadmajeed]

Did you face any issue with thread safety?

[ZevEisenberg]

The main news app uses flow controllers and UIKit. Haven't had many thread safety issues that I can recall, but our threading needs are pretty simple, and I imagine they'll get simpler with new concurrency things.

[krzysztofzablocki]

main apps were MVVM+C, TCA made development really fast

[simme]

I'm using TCA for my two apps Handla and Plantry. The latter is only partly converted thus far. The former was built from the ground up using TCA.

Converting an old codebase has been pretty straightforward, started at the leaf nodes and new features. Working my way inwards.

Building a new app from scratch with TCA was a total joy! Even when building with UIKit I was able to get up and running quickly because it makes mocking data and functionality so easy!

Every time I work on an app that doesn't use TCA I miss it!

[erikolsson]

I’ve used TCA for a bunch of different apps. My latest one is called Effekt, built on TCA + UIKit + Metal:
https://apps.apple.com/us/app/effect-live-wallpaper/id1616146386

[rcarver]

The upcoming 2.0 release of my app Series is TCA + SwiftUI. It's in TestFlight now, happy to add you.

I've been using TCA for just about a year now, I converted a client's app from vanilla SwiftUI and then decided to use it for my own app rewrite. Overall it's saved me way more headaches than its created. When I follow the patterns things tend to go very well.

In that spirit, my 2c on making TCA more accessible is to define and document common patterns for using it. For me, the hardest part is designing for composition and composing state (sharing state, delegating effects to parent). There's so much knowledge in the Point Free videos, isowords and the case studies but it's hard to get a quick tip when you're up against a new problem.

[ghost]

In that spirit, my 2c on making TCA more accessible is to define and document common patterns for using it. For me, the hardest part is designing for composition and composing state (sharing state, delegating effects to parent). There's so much knowledge in the Point Free videos, isowords and the case studies but it's hard to get a quick tip when you're up against a new problem.

I wish I could upvote this comment a million times.

[jdowd7]

We are using TCA @ Exer Labs- its the basis of our 2.0 Gait Application.
We focus on providing solutions in the Physical Therapy and Elder Care space with machine learning and augmented reality all on iOS.

[romero-ios]

My budgeting app, Money Flow, was re-written from MVVM to TCA for iOS 15 - https://www.moneyflow.app

[junjielu]

Our app PDB is building entirely on TCA + UIKit.
Thank you so much for this extraordinary framework!

[zboralski]

We just got approval for our new app that uses TCA + SwiftUI. It is really a personal data management app (starting with the Contacts domain). The user interface is completely content-agnostic and everything from the user interface perspective is a graph of propositions you can interact with based on each proposition's type.

https://apps.apple.com/app/id1638189843

Manage and present your contacts with the Belua app.

Features:

Organise

• Display generative art for contacts without photo.
• Use tags to categorise your contacts.
• Use the touch action to surface contacts in recent.
• Sort by recent, by recently added, by tag or by country.
• Privacy Built-In from the start.
• Actions such as favourite, tag and hide work across devices if you are using iCloud.
• Works in Airplane mode

Search

• Search text in contacts
• Diacritic insensitive [a diacritic is a glyph added to a letter or to a basic glyph].
• Works with natural language text to ensure correct behaviour in multiple scripts and languages such as Chinese or Japanese.

The app also features privacy built-in from the start, so you can feel confident that your information is safe.

[mluisbrown]

The Trading.com app (https://apps.apple.com/app/id1576478434 - US only) is built entirely using TCA and UIKit. Initially it was developed using the ReactiveSwift fork of TCA as we were targeting iOS 12 as a minimum. However that changed during development and the code was re-factored to use the "real" TCA and Combine.

An interesting point is that the Android version of the app was also developed using an in-house Kotlin port of TCA.

It's a pretty complex app with a lot of real time information streams and continuous UI updates. If you have access to the US App Store you can try it out without having do any real trading by using a demo account with fake money.

Since then I moved on to work at Argent and the iOS app is mostly TCA, although there is some older code using an in-house redux style architecture.

Right now I can't imagine myself working on any iOS app not using TCA. The difference it makes is really immense.

[FredericRuaudel]

I've rebuild the app I'm in charge at Ver de Terre Digital using TCA and I'm really happy with the result. The development is more flexible, I can easily add new features, tests them, create preview apps to live test them, and simulate screen state to generate my AppStore screenshots using fastlane snapshot ! I highly recommend it ! 💚

Soildiag on the AppStore

[jeffersonsetiawan]

Tokopedia: Indonesia Ecommerce app
It's using RxSwift version of TCA because we still support iOS < 13 and still using cocoapods.

Really enjoy using the TCA, highly recommended!

[saroar]

wow I am ready for work your company let me know if you need any dev :)

[emrdgrmnci]

Hi all 👋🏼

I have created a NBA teams and players list app with The Composable Architecture (TCA).

🔗 Here's the link:
https://github.com/emrdgrmnci/MatchScoresTCA

[Sajjon]

Radix DLT's wallet app uses TCA

[akashsoni01]

Currency exchange app written in TCA. https://github.com/akashsoni01/currency_exchange_app

[Echim2016]

Hi all,

I'm currently launching an engaging icebreaker game app called "Check-in Box" using TCA and currently supports Traditional Chinese only. This app sparks conversations through specific topics and fosters closer connections between you and your friends. 🧋

https://github.com/Echim2016/check-in-box-ios
https://apps.apple.com/us/app/id6474719999

[rokon-uddin]

Hi,
At Monstarlab we maintain a TCA-based iOS project starter template. Feel free to have a look and share your feedback:
https://github.com/monstar-lab-oss/swiftui-template-tca

[ba01ei]

I migrated a simple app to entirely use TCA, and with strict-concurrency fully enabled too:
https://apps.apple.com/us/app/just-keep-favorite-photos/id6461162504

it's a super simple app (it cleans up your photo library), but still, migrating to TCA is fun :)

[davidcairns]

We use TCA for the biggest & most complex parts of Butterfly iQ, which is a FDA-approved medical ultrasound that plugs into a iPhone/iPad. We rewrote our whole exam screen (the central & most complex part of our app) in TCA way back in 2020, and since then most new code is written using TCA.

So: it’s not just for word games and to-do apps! 😜

I would be remiss in not mentioning that we won an Apple Design Award in 2019 😏

[adriansergheev]

geoguessr - for old photos in tca
it was written last year and it is open source since a few months now 🙂

[uniqby]

My very first app using TCA – Bible Reader

[Raidansz]

An Audio Player in TCA
https://github.com/Raidansz/AudioPlayer-SwiftUI-TCA

[gcohen-dev]

It looks nice, I would export the CurrentValueSubject to a client and use AsyncStream, which make more sense IMO, then you don't need to use ObservationStateIgnored.

[wshamp]

https://apps.apple.com/us/app/sprigling/id6569230006

-100% TCA uses firebase auth, Firestore, Apple Subscriptions, Swift 6

Also started a youtube channel going over the features and how I did them in TCA. - https://www.youtube.com/@ThicketStudios

[hpetru]

https://github.com/github/CopilotForXcode is using TCA, it's a very well written extension btw!

[hpetru]

Here is one more: https://github.com/Saik0s/Whisperboard 😊

[dpitkevics]

Caliverse - calisthenics and bodyweight fitness app rewritten from Flutter to Swift + SwiftUI using TCA.
https://apps.apple.com/us/app/caliverse-bodyweight-fitness/id1472004214

[hanneskaeufler]

I built an app that is arguably 20 years late to the market: Meet GalleryMagic for quickly generating an HTML image gallery just by dropping a bunch of images into the app. It has a few of the low-hanging fruit features you might expect, and can also publish galleries straight to the web. So I guess now I am also in the hosting business lol. We'll see ...

Of course built using TCA (second time of using in in an app that I actually shipped, again thoroughly enjoyed it). I have some light usage of swift-sharing in there as well, though not much yet, and swift-sharing to me also hasn't quite "clicked" yet as the general TCA approach has.

As is typical for me being a "I enjoy the developing part, not so much the marketing part:, market research and investment into publicizing it are at a low bar 😆 I also tried my best to ship it early, so I'm not yet proud of my creation. Bugs and warts can be found!
Anyway, here's the App Store link: https://apps.apple.com/us/app/gallerymagic/id6744827234