MeeGo
MeeGo was a mobile Linux operating system formed in February 2010 when Nokia folded Maemo and Intel folded Moblin into one project hosted by the Linux Foundation, and it ran from that merger to its closure in late 2011, by which point exactly one phone, the Nokia N9, had shipped with a version of it.
What MeeGo Linux was
MeeGo Linux was a full operating system stack, not an application and not a distribution layer bolted onto something else. It carried its own kernel, its own package format, its own toolchain and its own user interface layers, and it targeted four device classes at once: handsets, netbooks, in-vehicle infotainment systems and connected televisions. The project was governed through the Linux Foundation rather than by either sponsor directly, with a technical steering group drawn from Nokia and Intel.
Two things made MeeGo unusual for its moment. It was genuinely dual-architecture, building for both ARM processors such as the Texas Instruments OMAP parts in Nokia hardware and for Intel’s x86 Atom, from a single source tree. And it was open in a literal sense: the source was public, the build system was public, and anyone could produce an image. That openness is why the platform outlived its sponsors, and why the story of Maemo and the Nokia Linux line does not stop in 2011.
MeeGo here means the operating system. Several unrelated mobile applications have used similar names in the years since; this reference covers the Linux platform only, and hosts no firmware, images or repackaged applications of any kind.
How the Maemo and Moblin merger worked
The Maemo and Moblin merger worked by taking the parts each side was strongest at and discarding the duplicates. Nokia contributed Maemo, the Debian-based platform it had shipped on the 770, the N800, the N810 and the N900, along with Qt as the application framework and a decade of experience shipping Linux on handhelds. Intel contributed Moblin, which it had started in 2007 for netbooks and mobile internet devices and had handed to the Linux Foundation in April 2009, along with x86 optimisation work and its Atom roadmap. The announcement was made at Mobile World Congress in Barcelona in February 2010.
The merger was not symmetrical, and the asymmetry mattered to anyone who had been packaging software for Maemo. MeeGo took Moblin’s RPM packaging rather than Maemo’s Debian packages, which meant existing Maemo packages did not simply carry across. It took Nokia’s Qt as the sanctioned application framework, which meant Moblin’s GTK-based applications were the ones being asked to move. Both communities lost something in the exchange.
The MeeGo releases, 1.0 to 1.2
MeeGo made three numbered releases between May 2010 and May 2011, each roughly six months apart, on a schedule the project published in advance.
| Release | Date | What it delivered |
|---|---|---|
| MeeGo 1.0 | May 2010 | Core plus a netbook user experience for Atom, and a developer image for the Nokia N900 |
| MeeGo 1.1 | October 2010 | Netbook, in-vehicle infotainment, and the first preview of a handset user experience |
| MeeGo 1.2 | May 2011 | Updated core, refreshed netbook and handset builds, wider hardware adaptation |
The releases tell you where the project’s weight actually sat. The netbook build was the one that worked end to end on shipping hardware from the first release; the handset build was still a preview eighteen months into the project. Developers who wanted to work without hardware used the emulator supplied with the MeeGo SDK, which ran an image under QEMU on an ordinary desktop machine. Anyone who had built for Maemo previously would have been using Scratchbox instead, and the change of tooling was one more thing to relearn.
Maemo vs MeeGo: what actually changed
Maemo and MeeGo differed in four concrete respects, and confusing them is the single most common error in accounts of this period.
- Ownership: Maemo was Nokia’s alone. MeeGo was jointly sponsored by Nokia and Intel and hosted by the Linux Foundation.
- Packaging: Maemo used Debian packages and apt. MeeGo used RPM.
- Architecture: Maemo shipped only on ARM devices. MeeGo built for ARM and for Intel Atom from one tree.
- Scope: Maemo targeted internet tablets and one phone. MeeGo targeted handsets, netbooks, cars and televisions.
What did not change was the underlying idea. Both were ordinary Linux systems with a real package manager, a real shell and a filesystem you could write to, running on hardware you had bought. The N900 running Maemo 5 could open a root terminal out of the box, and MeeGo inherited that assumption rather than abandoning it.
Applications, Qt and the MeeGo store
Applications on MeeGo were written against Qt, and specifically against Qt 4 with QML for interface work, which the project named as the application development environment from the merger onwards. That decision was the strongest continuity between the two parent platforms: Nokia had already been moving Maemo 5 applications toward Qt before MeeGo existed, so Qt code written for the N900 was the code with the best chance of surviving the transition.
Distribution was never unified. Intel ran the AppUp Center for MeeGo netbook software on Atom machines; Nokia sold Harmattan applications through its own Ovi Store, later renamed the Nokia Store. A developer targeting both device classes was therefore dealing with two storefronts, two review processes and two sets of packaging rules, which is a fair summary of how far the merger got before it was overtaken.
The N9, the one phone that shipped with MeeGo
The N9 was the one phone that shipped with a MeeGo-branded system, announced by Nokia in June 2011 and on sale from late September 2011 in a limited set of markets. Its operating system was labelled MeeGo 1.2 Harmattan, and the label needs unpicking: Harmattan began life as Maemo 6, kept Debian packaging rather than RPM, and was aligned to the MeeGo application programming interfaces rather than built from the MeeGo core. It was a Maemo descendant wearing a MeeGo name.
The hardware was a 3.9in AMOLED display at 854×480 under curved glass, a 1 GHz Texas Instruments OMAP 3630, 1 GB of RAM, 16 GB or 64 GB of storage, an 8 megapixel camera and a seamless polycarbonate body with no home button at all. Nokia never published sales figures for it, and any number you find quoted for N9 sales is an estimate rather than a reported one.
What happened to MeeGo after 2011
MeeGo after 2011 ended as a sponsored project and continued as a set of forks. Nokia announced its strategy change in February 2011, naming Windows Phone as its primary smartphone platform, which removed the larger of the two sponsors from the handset side while the N9 was still months from release. In September 2011 the Linux Foundation and Intel announced Tizen, and MeeGo was folded toward it; Tizen took a different technical direction, favouring web applications over Qt, so the code did not simply carry over.
The parts that survived did so in community hands. Mer, a fork of the MeeGo core stripped back to a reusable base, was picked up by former Nokia engineers who left to form Jolla in 2011. The system they built on it, Sailfish OS, is still developed and still shipping, which makes it the only line of descent from the merger that is a going concern rather than a historical record. That continuity is why MeeGo remains worth documenting precisely: it is not a dead end, it is the middle of a chain that starts with the 770 and has not yet stopped.