Every year we ship a new major version of Nothing OS. It shows up on your phone as a simple notification, but the journey behind it is anything but simple. Here’s how that update actually comes together.

Where it all begins

Google releases a new major version of Android every year. For users everywhere, it is a moment filled with excitement. New design touches. Smarter intelligence. Better privacy controls.

The path from Google’s first line of code to the update on your device takes months of coordination, thousands of tests, and a huge focus on stability. Once Google ships the official Android release, we look at it through our own lens to shape what becomes Nothing OS.

The Nothing Way

We build OS updates with one goal. Make the experience effortless. That means focusing on features that bring real value to your everyday use. Personal customisation. Productivity tools. Creative features. Smarter behaviour. Not visual noise.

A great OS should disappear into the background. It should feel fast, fluid, and reliable.

Baking a New OS

Think of the OS like a cake. Google makes the base. Chipset partners prepare the plate. We build the frosting. Each piece matters. The timing matters even more.

How It Begins

Every Android update is built on three layers. All three must come together perfectly before a single phone can be updated.

Android Open Source Project (AOSP)

Everything starts with Google. AOSP is the foundation of Android. It includes the system frameworks, APIs, and kernel that power how your phone works. Google ships two release tracks every year.

Major versions like Android 15 or 16.
Quarterly Platform Releases that refine the system between major updates.

We begin our work early using Google’s Platform Development Kit to understand how our features should evolve. When the final AOSP build goes public and the platform stabilises, we start the full merge and testing cycle for Nothing OS.

Chipset Partner and the Board Support Package (BSP)

AOSP is universal. It does not know anything about the specific hardware inside phones.

Chipset partners like Qualcomm and MediaTek customise AOSP so it can run on their processors. This becomes the Board Support Package (BSP). It contains the essential drivers for cameras, displays, modems, audio, sensors, power management, and more. Without the BSP, no Android device would boot.

Once complete, the BSP is handed to OEMs like us.

The OEM (Original Equipment Manufacturer)

This is where Nothing OS comes to life.

As soon as we receive the Board Support Package (BSP), our teams integrate the hardware layer into our own features, design language, and internal frameworks. This sets the foundation for the full tuning process. Every model, from our flagship phones to our more affordable ones, is tuned individually for performance, battery life, connectivity, animations, and overall reliability.

Inside the Update, From Beta to Stable

This stage brings all layers together into a working build. From here, development, testing, and certification start in parallel. This is also the point where the community begins to shape the final outcome.

Merging and Porting

Our engineers combine Google’s Android code, the BSP, and Nothing OS. Thousands of files are merged. Conflicts are resolved. Features like the Glyph Interface, camera tuning, and animations are rebuilt for the new Android version. Each phone model requires its own specialised work.

Testing and Quality Assurance

Development and testing run side by side. Every build moves through strict checks for performance, battery life, heat, app behaviour, network strength, and animation smoothness. Some stress tests run for days to expose rare issues like memory leaks or slowdowns. The cycle continues until the system reaches a level of polish that feels right.

Internal Testing and Open Beta

Before anything reaches public beta, it lands on our own devices. Employees and a small group of trusted community members use early builds as daily drivers. This is where we catch usability issues that only show up in real life.

This stage is called dogfooding, which simply means testing your own product before you ship it.

After this, we move to Open Beta. More community members join, testing real usage across different carriers, regions, apps, and network conditions. Open Beta is often staggered by device because each model uses different hardware, and some stabilise faster than others. Rolling out in stages helps us isolate issues and avoid spreading problems across all devices at once.

The feedback from this phase helps us refine performance, resolve edge cases, and stabilise the system ahead of the final release.

Google Certification (XTS)

When the OS reaches internal stability, it moves to Google certification. This is not a single test. It is a large collection of suites known as XTS, short for eXtended Test Suite. XTS includes the Compatibility Test Suite (CTS), Vendor Test Suite (VTS), GMS Test Suite (GTS), Security Test Suite (STS), and several others.

These suites check compliance with Android standards, covering everything from permissions and encryption to app behaviour and hardware interaction. If any test fails, we fix the issue, rebuild the software, and resubmit until every requirement is met.

Only after a full pass can we package the final build for rollout.

The General Release

After certification, the update enters the general release phase. This is the version made for everyone. It includes all new features, polish from internal testing, refinements from the community, and any additions that were not ready during beta. Features introduced earlier are also refined so the final release feels complete.

We begin with a controlled rollout. This helps us monitor real-world performance across different regions, carriers, and usage patterns. If anything unexpected appears, we can pause, correct the issue, and continue the release without impacting all users at once.

The goal is simple. Deliver the smoothest and most stable update possible.

The People Behind the Process

That small update notification represents months of work by teams across the world.

Project Managers plan schedules and dependencies.
Product Managers decide which features land.
Designers refine spacing, motion, and the feel of the OS.
Engineers merge thousands of files and rebuild key features.
QA testers push every scenario to its limits.
Customer Support prepares to guide users once the update goes live.
Community members test early builds and shape the final experience.

Our engineering culture is built on ownership. Many features are owned end to end by a single domain expert. The same person who builds a feature is responsible for its performance. That is how Nothing OS stays consistent and reliable.

In Perspective

What looks like a small pop-up hides one of the most complex processes in consumer technology.

From Google’s code to the chipset layer to our internal design, engineering, testing, and certification, the journey often takes half a year or more. Just like baking a cake, every layer has to come together perfectly before it is ready for everyone.

An OS update may only be a download on your screen, but behind it sits months of craft and care to make your phone feel just right.

If you made it this far, your attention span deserves a medal.

So here’s the answer to the classic question everyone is about to ask…

“When is the stable release coming?”

Answer: 👀