When Getting Sherlocked Leads to Something Better: The TranslateKit Journey

When Apple introduced String Catalogs at WWDC 2023, I felt my heart sink. I had just spent a full year building RemafoX, an Xcode extension for app localization, only to see much of its functionality become part of Xcode itself. As an indie developer, this was a significant setback – RemafoX was meant to be my flagship app after going indie full-time in 2022.

Yet, as I dug deeper into String Catalogs, I realized something interesting: Apple's deep SwiftUI integration offered possibilities that weren't achievable through Xcode extensions. Instead of fighting the tide, I decided to embrace it. Over a single weekend, I built a simple tool that could parse String Catalogs and handle machine translations. That tool became TranslateKit.

An Unexpected Success Story

What started as a weekend project for personal use quickly became my most successful app to date. Developers worldwide embraced TranslateKit's simplicity and efficiency. The feedback exceeded my expectations for such a quickly written app, and with it came valuable insights about what developers really needed from a localization tool. Just recently, a fellow indie developer shared on Bluesky:

This resonated deeply with me. Many developers overestimate the effort required to localize their SwiftUI apps. Getting to 90% localization coverage is surprisingly straightforward with today's tools, and reaching that last 10% is becoming easier than ever.

Consider this: About 80% of the world's population doesn't speak English. Lack of localization is statistically the number one reason globally for an app being inaccessible to users. Every app should be localized – it's not just about reaching more users, it's about making your app truly accessible. And I've made it my mission to make this as easy as possible for Indie developers.

The Evolution to TranslateKit 3

After a year of learning from user feedback, I realized I could do much better. The biggest pain point? Setting up API keys. Developers found themselves registering for various translation services, dealing with credit cards, and managing API quotas. It was too much friction for what should be a simple process.

Then there were the translation quality issues. While my machine translation integrations were good, they often missed crucial context by translating each string in isolation. A button that made perfect sense in English could become awkwardly verbose or totally miss the context in other languages. By processing strings in batches and providing full app context to the AI, TranslateKit 3 maintains consistency and an appropriate tone across your entire app.

Project-wide management was another crucial improvement. Previously, developers had to remember to drag and drop their InfoPlist.xcstrings file separately – leading to situations where apps would be localized but permission dialogs would still appear in English. Now, TranslateKit handles your entire project at once, ensuring nothing gets missed.

This led to a complete rebuild, focusing on what matters most to developers:

1. Zero setup required - no more API keys or service registrations
2. Context-aware AI translations that understand your app's purpose
3. Project-wide localization that catches everything, including permission texts
4. Intelligent handling of your app's brand terms and terminology
5. Support for language-specific nuances like formality and cultural context

The results? Translation errors reduced by about 90% compared to traditional services. On top of that, TranslateKit 3 introduces AI proofreading, a unique feature that can improve any existing translations, whether they're from an older version of TranslateKit or any other source. Just select the languages to check and let the AI fine-tune your translations for even better accuracy.

See for yourself what Noah, the developer behind Proxyman, is saying:

And with the new pay-what-you-need pricing approach, localization is finally affordable for all indie developers. You can test the waters by adding a single language for just $1 (with a free first month to try it out), or go all in and reach 5x more users by adding the top 10 languages to an average-sized app in just 4 minutes, for less than $5. I hope this makes app localization as affordable as possible and removes one more barrier for developers considering it.

Looking Beyond iOS

But I didn't stop there. As I shared in my recent post about the TranslateKit SDK, SwiftUI developers can now benefit from automatic key generation with the #tk macro and access over 2,000 pre-translated common UI texts with a call like TK.Action.cancel. Both will help further improve the accuracy of localization. And while iOS development will always be my primary focus, I've designed TranslateKit's core translation system to be platform-agnostic, paving the way for supporting other app platforms in the future, Android and Flutter being the first.

I'm putting the finishing touches on a comprehensive video guide that will show just how straightforward app localization has become. Because sometimes, seeing is believing – and I want every developer to know they can make their app global without the headaches they might expect. For now, this 50 sec video must suffice:

Try It Yourself

The best way to understand how easy localization has become is to try it. Add a String Catalog to your project, build your app, and you might be surprised to find it already mostly has all the entries to be localized. With TranslateKit 3, you can translate them with context-aware AI, ensure consistency across your entire project, and reach users worldwide faster than ever.

The journey from RemafoX to TranslateKit has taught me that sometimes, what seems like a setback can lead to building something even better. By embracing new technologies and really listening to developer needs, I've created a tool that makes app localization easier & better. Patience always pays off in the end!