Introduction
In early 2009, the smartphone market was still anyone’s game. Apple had shipped the iPhone 3G and was gaining momentum fast. BlackBerry owned the enterprise. Nokia and Symbian still dominated global market share. And Google? Google had shipped exactly one phone — the T-Mobile G1 (HTC Dream) — running a rough, unfinished Android 1.0 that lacked basic features like an on-screen keyboard.
Android 1.5 Cupcake was officially released on April 27, 2009.
This release was Google’s first real attempt to turn Android from a developer experiment into something consumers might actually want. Compared to Android 1.0 and 1.1, Cupcake introduced the on-screen soft keyboard, home screen widgets, video recording, stereo Bluetooth, and auto-rotation — features the iPhone already had and Android desperately needed to compete.
Whether you’re looking up API compatibility for a legacy app or just curious about where Android started, this guide covers everything about the release that put Android on the map.
Quick Facts
| Item | Value |
|---|---|
| Version | Android 1.5 |
| Codename | Cupcake |
| API Level | 3 |
| Release Date | April 27, 2009 |
| Linux Kernel | 2.6.27 |
| Initial Device | HTC Magic (T-Mobile myTouch 3G) |
| Previous Version | Android 1.1 (Petit Four) |
| Next Version | Android 1.6 Donut |
What’s New
On-Screen Keyboard
Before Cupcake, Android phones required a physical slide-out keyboard. The G1 didn’t even have a software keyboard — you either typed on the hardware keys or you didn’t type at all. This was a deliberate design choice by the original Android team, who believed physical keyboards were superior.
Cupcake reversed that decision, and it was the right call. The new soft keyboard supported auto-correction, word prediction, and a suggestions bar above the keys. It wasn’t as polished as the iPhone’s keyboard — early users complained about accuracy — but it unlocked the ability to build thinner, keyboard-free Android phones. Every touchscreen Android phone sold since exists because of this one feature.
Third-party keyboard support also arrived here, meaning Swype and SwiftKey (when they eventually launched) had a platform to plug into.
Home Screen Widgets
Cupcake introduced the widget framework, a feature that became one of Android’s defining differentiators from iOS for over a decade. Users could place interactive mini-applications directly on the home screen: a clock, calendar, music player, picture frame, and search bar.
Was it revolutionary? For Android, genuinely yes. Apple wouldn’t add widgets until iOS 14 in 2020 — 11 years later. The implementation in Cupcake was basic (no resize, no scrollable widgets, no third-party widgets until Donut), but the foundation was laid.
Video Recording and Playback
Android 1.0 couldn’t record video at all. The G1 shipped with a camera sensor and no way to capture video — a glaring omission when the iPhone 3G had it. Cupcake added video recording in MPEG-4 and 3GP formats, along with playback support for those formats.
It also added the ability to upload videos directly to YouTube and photos to Picasa, which made sense given Google owned both services. The quality was mediocre — 320×240 at best on most hardware — but at least the record button existed now.
Stereo Bluetooth (A2DP & AVRCP)
Cupcake added the A2DP (Advanced Audio Distribution Profile) and AVRCP (Audio/Video Remote Control Profile) Bluetooth profiles. This meant you could finally stream stereo audio to wireless headphones and control playback remotely. Android 1.0 only supported mono Bluetooth for headsets, which was useless for music.
Copy and Paste in the Browser
Android 1.0’s browser had no copy/paste. Cupcake added long-press to select text in web pages, plus the clipboard framework that would eventually extend system-wide in later versions. Small feature, massive quality-of-life improvement.
User Interface Changes
Cupcake refined Android’s UI in ways that set the visual language for years to come:
- Animated screen transitions: Window and activity transitions got fade and slide animations. By modern standards they were simple, but in 2009 they made the OS feel responsive rather than clunky.
- Auto-rotation: The accelerometer now triggered screen orientation changes automatically when you tilted the phone. The G1 relied on opening the keyboard to rotate.
- Live Folders: A new launcher feature that let developers create dynamic folders whose contents updated in real time — contacts, recent documents, starred items. It never became widely used and was eventually deprecated, but it showed early ambition.
- Refined notification shade: Notifications got expandable actions and a clearer layout.
The overall UI still looked rough compared to iPhone OS — inconsistent padding, clashing UI patterns, and zero design system. Material Design was still five years away.
Performance Improvements
Cupcake’s performance gains were modest but meaningful for 2009 hardware:
- Faster camera startup: The camera app launched noticeably quicker than on 1.0/1.1.
- Improved GPS acquisition: GPS lock times dropped significantly with better satellite detection algorithms.
- WebKit updates: The browser got a newer WebKit engine with faster JavaScript execution (though still far behind Mobile Safari at the time).
- Dalvik VM optimizations: Minor garbage collection improvements that reduced stutter during memory-intensive operations.
Nobody would call Cupcake “fast” by current standards — the HTC Magic had a 528 MHz Qualcomm MSM7200A with 192 MB RAM — but it was a visible step up from the G1’s Android 1.0 experience.
Security Improvements
Security in Cupcake was, frankly, primitive compared to modern Android. No verified boot, no encryption by default, no runtime permissions. Apps either accepted all permissions at install time or didn’t install at all.
What Cupcake did add:
- Permission model enforcement: Android’s install-time permission system was tightened — apps declared
AndroidManifest.xmlpermissions and the OS enforced them more consistently. - SUID/SGID restrictions: System binaries had stricter privilege separation.
By today’s standards, running Cupcake in 2025 is a security nightmare. But in 2009, mobile malware was barely a thing, and the permission model was ahead of what iOS offered at the time (which was essentially: trust Apple’s review process or jailbreak).
Developer Features
Cupcake bumped the API level to 3 and shipped a new SDK with several additions:
| API | Description |
|---|---|
android.widget |
Widget framework — AppWidgetProvider base class, RemoteViews for cross-process UI |
android.hardware |
Camera API extended with MediaRecorder for video capture |
android.speech |
Speech recognition framework via RecognizerIntent |
android.bluetooth |
A2DP and AVRCP profile support |
android.view.inputmethod |
Input Method Framework for third-party keyboards |
android.content.ClipboardManager |
System clipboard API |
The input method framework was particularly important — it meant developers could build and distribute custom keyboards through Android Market, creating an entire subcategory of apps that couldn’t exist on iOS.
Devices That Shipped With Android 1.5 Cupcake
Notable smartphones that launched with Cupcake:
- HTC Magic (T-Mobile myTouch 3G in the US) — The first Android phone without a physical keyboard, and the launch device for Cupcake.
- Samsung Galaxy i7500 — Samsung’s first Android phone, with a 3.2-inch AMOLED display, a rarity at the time.
- HTC Hero — Shipped with Cupcake but overlaid with HTC Sense, the first major manufacturer skin. Sense added its own widgets, social media integration, and a redesigned launcher — setting the pattern for every OEM skin that followed.
No Nexus device existed yet; the Nexus program began with Android 2.1 Eclair and the Nexus One.
Comparison With Android 1.1
| Android 1.1 (Petit Four) | Android 1.5 Cupcake |
|---|---|
| Physical keyboard required | On-screen keyboard with auto-correct |
| No home screen widgets | Widget framework with clock, calendar, search |
| No video recording | Video recording in MPEG-4/3GP |
| Mono Bluetooth only | Stereo A2DP + AVRCP |
| Manual screen rotation | Auto-rotation via accelerometer |
| No clipboard | Copy/paste in browser |
| API Level 2 | API Level 3 |
Cupcake wasn’t a complete rewrite — the core architecture remained the same — but it filled gaps so obvious that shipping without them had been embarrassing. It was the version that made Android feel like a real smartphone OS, not a beta.
Legacy and Impact
Cupcake established three things that defined Android for the next decade:
-
The dessert codename tradition. Google’s decision to name releases after sweets in alphabetical order became one of the most recognizable branding moves in tech. The lobby of Building 44 at Google’s Mountain View campus got its first Android statue — a giant cupcake with the bugdroid on top.
-
The widget framework. Android’s widget system — refined through Donut, Eclair, and beyond — remained a core differentiator from iOS for 11 years.
-
The soft keyboard + touchscreen form factor. Cupcake’s on-screen keyboard enabled the HTC Magic, then every slab-style Android phone that followed.
Adoption was slow. Cupcake never achieved mass-market penetration — Android wouldn’t hit critical mass until 2010 with the Motorola Droid and Galaxy S. But it proved Google could iterate fast and ship features consumers actually wanted.
End of Support
Cupcake’s support window was brief:
- Google Play Services: Not compatible with Cupcake. Google Play Services launched in 2012 and required Android 2.2 Froyo or higher.
- Android Market: The original Android Market eventually stopped working on Cupcake as Google migrated to Play Store with higher API requirements.
- Modern app compatibility: Zero modern apps support API Level 3. The minimum for any active Play Store app is typically API Level 21 (Android 5.0) or higher.
- Last security update: Cupcake never received formal security patches — that framework didn’t exist until later Android releases.
If you have a Cupcake device today, it’s a museum piece. It can’t browse the modern web, can’t run modern apps, and has no security protections against anything.
Fun Facts
- The first dessert name: Google internally named versions after desserts from the beginning (Android 1.0 was “Alpha,” 1.1 was “Petit Four”), but Cupcake was the first to be publicly branded with a dessert name.
- The statue tradition: The first Android lawn statue at Google’s Building 44 was a giant cupcake. Every Android release after got its own statue, creating an ongoing tradition at the Mountain View campus.
- Easter egg: Tapping “Android version” in Settings repeatedly brought up a simple cupcake illustration — the first Android Easter egg. It was basic compared to later interactive Easter eggs, but it started the tradition.
- Why “Cupcake”? According to Android engineer Dan Morrill, the name came from an internal joke about the release being a “small, sweet update” after the rough 1.0 launch.
Frequently Asked Questions
What API level is Android 1.5 Cupcake?
API Level 3.
Is Android 1.5 Cupcake still supported?
No. Cupcake has been unsupported since 2010. Google Play Services doesn’t run on it, and it receives no security updates.
Can Android 1.5 Cupcake run modern apps?
No. Modern Android apps target minimum API levels between 21 and 26. Cupcake’s API Level 3 is fundamentally incompatible with any app published in the last decade.
Which phones received Android 1.5 Cupcake?
The HTC Magic (T-Mobile myTouch 3G), Samsung Galaxy i7500, and HTC Hero shipped with Cupcake. The T-Mobile G1 also received an over-the-air update from Android 1.1 to 1.5.
Is Android 1.5 Cupcake secure today?
Absolutely not. No verified boot, no encryption by default, no runtime permissions, no security patches in over 15 years. Connecting a Cupcake device to the internet in 2025 is a security liability.
Final Thoughts
Android 1.5 Cupcake wasn’t a masterpiece. The UI was inconsistent, performance was mediocre even on 2009 hardware, and it was still missing features like multi-touch (Apple held patents that scared Google) and CDMA support.
But it was the moment Android stopped being an experiment and started being a product. The on-screen keyboard, widgets, video recording, and auto-rotation weren’t just feature checkboxes — they were the foundation of a platform that would eventually run on billions of devices.
Cupcake proved Google could ship. Donut, Eclair, and the versions that followed would need to prove Google could scale.
Related Articles
- Android Version History (2008–Present)
- Android 1.6 Donut: Complete Guide
- Android API Level Chart
- Android Codenames Explained
- Android 1.0 & 1.1: The Pre-Cupcake Era
- Evolution of Android User Interface
References
- Official Android 1.5 Platform Highlights (developer.android.com)
- Android Developers Blog: “Android 1.5 SDK, Release 1” (April 2009)
- Android Open Source Project (AOSP) — android-1.5r1 tag
- Dan Morrill, “A History of Android Codenames” (Google internal, later published)
- HTC Magic / T-Mobile myTouch 3G product documentation