We’ve rebuilt Things Cloud from the ground up. The system that keeps your to-dos in sync is now faster, built with modern technology, and ready for the future. A behind the scenes look.
For over a decade, Things Cloud has kept your to-dos in sync across devices. Many of you have told us how much you appreciate its reliability – it just works. But behind the scenes, a major transformation has quietly taken place: we’ve rebuilt the entire service from the ground up.
The new cloud is already up and running – and you didn’t notice a thing. That was by design. From the outside, everything appears the same. But under the hood, everything changed: the infrastructure, the architecture, and the language it’s written in.
This post takes you behind the scenes: why we rebuilt Things Cloud, why we chose to write it in Swift, and how we transitioned without skipping a beat.
This will be a bit more technical than usual. If that’s not your thing, the summary above is already the key takeaway: Things Cloud is now faster, more modern, and ready for the future.
Why we rebuilt Things Cloud
Fourteen years ago, we designed Things Cloud on a solid mathematical foundation. The core algorithms were crafted with care – capable of handling offline edits and resolving sync conflicts across multiple devices. Over time, we refined them and added features like Fractus, our granular text-sync engine.
That theoretical foundation has proven itself throughout the years, and we’ll continue to rely on it. However, the technology we used for its implementation began to show its age. Technology had evolved, as did our needs, and the system we built over a decade ago became increasingly difficult to maintain and extend.
To address this, we carefully reviewed every layer of Things Cloud – its code, architecture, and infrastructure – and explored how modern technologies could help us move forward. It became clear to us that we needed more than gradual improvements – a full rebuild was necessary. Our goal wasn’t just to keep Things Cloud running, but to lay the groundwork for future improvements and unlock new possibilities in the years ahead.
Why Swift?
Swift has become Apple’s flagship programming language for building modern apps, and over the years we’ve adopted it for much of the code in Things itself. It’s fast, safe, and expressive. So four years ago, when we set out to rebuild Things Cloud, we saw a promising opportunity: to use Swift on the server, too.
At the time, Swift was an unconventional choice. Unlike more mature server languages, it had a smaller ecosystem and fewer production-tested tools. That said, Apple had shown a strong commitment to server-side Swift, and there was a growing open-source community. The upsides were also very compelling: great performance, modern language features, and the ability to use the same language across both app and server code.
To see how things would go, we started small, building out a few components in Swift. As the system grew, so did our confidence. There were no real hurdles – just steady progress. In the end, it’s clear that this was a great choice. The new codebase is clean and robust, development moves faster, and the system runs with rock-solid stability – all while delivering a fourfold speed boost when processing sync requests.
For a deep dive into the technical details, check out our post on Apple’s Swift.org blog. We also gave a talk at last year’s Server-Side Swift Conference.
A seamless transition
Rewriting a cloud service is one thing – switching it on without disrupting its users is another.
To ensure a smooth transition, we ran the new cloud in parallel with the old one. While the old Things Cloud continued syncing everyone’s to-dos, the new cloud quietly processed the same data using its own logic and infrastructure. Every edge case and every corner of the sync model was tested under real-world conditions – without anyone ever noticing.
Once we were confident in the new cloud, we flipped the switch and moved everyone over. That transition happened early last year – and the new Things Cloud has been running reliably ever since.
With the migration done, we began taking advantage of the new architecture: refining our sync model, optimizing performance, and improving internal tooling and monitoring. That work wrapped up last month, marking the final step in this multi-year effort.
Ready for the future
The rewrite of Things Cloud didn’t change a thing on the surface – but it transformed everything beneath. The new cloud is faster, and easier to develop and maintain. Most importantly, it gives us a solid foundation to build on for the next decade and beyond.
At Cultured Code, we strive to build software with craftsmanship and care. Whether it’s a new app feature or a cloud overhaul, our goal remains the same: to build software you can rely on every day, for years to come.