Palm OS and the devices that ran it: An Ars retrospective

The start of something small

Meanwhile, Dubinsky noticed that the vast majority of Zoomer buyers already owned a PC. Virtually no Zoomer user printed from the device, and of all the applications the device included, only the date book, address book, and memo pad were widely used. Palm quickly realized that its customers didn’t want a second computer; they wanted an accessory.

At first, Palm began work on a successor to the Zoomer using a revised handwriting system called Graffiti. Instead of trying to match characters to multiple variations, as PalmPrint did, this time, there would be only one way to write. People would have to write differently from how they would ordinarily, but the upshot would be nearly perfect character recognition. But when Casio and Tandy abandoned the Zoomer II concept after the Zoomer’s market failure and Graffiti gained no other takers, VC investor Bruce Dunlevie challenged Hawkins to come up with his own device as a last-ditch effort.

Hawkins’ wish list for the new Touchdown project was deceptively simple: The device should be under $300, pocket-sized, battery-powered, as simple as a Day-Timer or Rolodex, and synchronizable with a PC using a side-car cradle rather than trying to be a PC. The size constraints demanded a small screen; Hawkins settled on a square, 2.5-inch display, 160 pixels on each side, and a boxy shape about as thick as a deck of cards to accommodate its dense internals. The cost constraints demanded cutting other options like expansion slots and a backlight (which also allowed for a smaller battery). For its CPU, the upcoming Motorola 68000-based DragonBall system-on-a-chip was selected, facilitating development on existing 68K-based Macintoshes until the chip was available in quantity.

The user interface received particular scrutiny. Hawkins set firm limits that any slow operation be reworked instead of showing a busy indicator, and explicit error messages should be avoided. Graffiti was a given because handwriting had to work, as no physical keyboard would have fit at the time. Mindful of how unusual such a device would be to many users, Ed Colligan declared that Touchdown should “delight the customer,” and developer Rob Haitani established a design theory he grandly christened the “Zen of Palm.” Mocking up the interface in HyperCard, Haitani carefully shaved down the number of taps required to perform a given task to make common operations quick and more unusual ones straightforward.

Unfortunately, Palm didn’t have enough money to launch the product, and Palm management worried that a larger corporation would turn Touchdown into another Zoomer. After failed negotiations with Motorola and Compaq, modem manufacturer US Robotics saw Touchdown (and in particular the cradle concept) as a way to get networking equipment into the home market and bought Palm outright for $44 million in September 1995 (about $89 million in 2024 dollars).

Early battles over compensation and manufacturing notwithstanding, USR took a relatively hands-off approach to its new acquisition—which was admittedly only a tiny part of its business at the time—and development proceeded generally unimpeded. As the release date loomed, however, the outside marketing team needed to know Touchdown’s ultimate name. Out of a morass of suggestions such as PalmPad, PalMate, Passport, Pilot, Comrade, and Way to Go emerged Taxi, until USR legal found the trademark had already been registered. With just weeks before sending the finished materials to the printing plants and the media, Dubinsky, Hawkins, and Colligan selected another: Pilot.

Despite USR’s formidable retail presence, Dubinsky and new sales VP Pat McVeigh, another Apple alumnus, decided to start small with 10,000 units in the first month, and Colligan seeded reviewers with prototypes for free publicity. Powering through last-minute glitches with the battery compartment and the CPU, the very first Pilots finally emerged in April 1996—again, not a Palm Pilot, just a Pilot.

Welcome to Pilot

Badged as US Robotics products, the Pilot 1000 ($299, or about $600 in 2024 dollars) and 5000 ($369, or $740) had 128K or 512K of memory built in, a Motorola DragonBall 68328 CPU at 16.58 MHz, and a serial port that connected to a Windows PC via the now iconic RS-232 serial cradle. (Mac support, despite the development environment, came later.) The top infrared beaming port that became a fixture on later Palm Pilots was absent in this first model; instead, a rear cover slid off to allow RAM upgrades. This unit in my collection is a 1000 that was secondarily upgraded with a 5000 RAM card.

In the box was a manual, cradle, and software. For connectivity, PalmConnect’s spiritual successor was a new, broader personal information manager (PIM) called the Pilot Desktop, provided in the package as 3.5-inch floppy disks. However, aware that many users would already have a PIM client they preferred, contractor IntelliLink (later Intellisync) separately provided “conduits” to many of the major players of the day, like Microsoft Schedule+ and, in particular, Lotus Organizer.

Every Pilot came with a standard set of PIM applications in ROM. These initially included the Address, Calc(ulator), Date Book, Memo Pad, and To Do List, supported by the Hot Sync, Memory, Prefs, and Security apps. These synchronized data with the Pilot Desktop and backed up and protected on-device data and software. Aside from relatively modest changes, these applications appeared in some form on every subsequent Palm OS device until the bitter end.

While Palm OS 1.0’s front end was a new and unique interface, its underlying operating system originally came from off the shelf. In 1978, Canadian engineering company KADAK developed a real-time operating system kernel for minicomputers operating oil and gas pipelines. By the early 1980s, its real-time operating system, named AMX, was cross-platform and expanding into new markets. As an example of its sophistication, Computerworld in 1984 remarked on an Intel 8085-based (not a typo, not an 8086) multiuser computer system using AMX as the kernel overlaid with additional custom software. It came with 80K of memory, floppies, and a 10MB hard disk and could serve up to 255 workstations with their own disks and printers over a custom 848Kbps network.

Crucially, AMX also supported the 68000 family. It provided real-time preemptive multitasking, scheduling with adjustable priorities, message passing, message queues, and semaphores, along with interrupt and dynamic memory management. In the Pilot, a low-level ROM routine ran at startup to initialize the hardware and then transferred control to AMX, or what Palm called the “microkernel.” Using AMX as the core of Palm OS gave Palm’s engineers a way to get an established, well-tested system foundation up quickly, but it belied little of AMX’s advanced capabilities because Palm’s license came with a serious caveat: The API to create tasks could not be exposed to user software. User applications thus could not add tasks of their own, though system software could, such as HotSync creating a separate thread to manage the serial connection.

In Palm OS, everything is a database, even applications. (This changed later on when SD card storage was introduced, but in main memory, the concept still remained largely the same.) Since the Palm OS was developed on the Macintosh, it was strongly influenced by the classic Mac OS; databases have creator codes, FourCC (four characters, 32 bit)-based like the Mac’s OSType, allowing an application and the databases it uses to be grouped together for the purposes of computing memory consumption, and FourCC types such as “appl” to indicate an application or “libr” to indicate a system library. A record in a database is accessed by index and could be read, written or deleted, or marked with attributes like read-only (yes, most of the OS in ROM was also stored in databases). The only restriction is that every record in a particular database had to be stored on the same memory device.

Applications and libraries were specialized databases that, like classic Mac applications, could also contain resources accessed by FourCCs and indexes of their own—thus the extension “.prc” for Palm Resource Code versus “.pdb” (Palm Data Base) for other databases. If you’ve used ResEdit to hack a classic Mac application, you know the general idea. Again, like the 68K Mac, executable code was stored in code resources rather than in an explicit binary fork. Code was executed in place wherever the OS ended up putting it.

Apart from the kernel, like most 68K-based systems, much of an application’s interaction with the OS was through A-line system traps (i.e., instructions with the upper nybble set to $Axxx, like TimeGetSeconds mapped to $A0F5 to get the 32-bit number of seconds for the current time). Palm OS continued its close conceptual relationship to the classic MacOS by additionally grouping its APIs into managers like the memory manager and the database manager. A PRC could also serve as a system library, just like an extension or control panel would do on a classic Mac. In fact, many such libraries were shipped read-only in ROM and were expanded and added to in later versions of the operating system.

On the other hand, for as elegant as the “everything is a database” approach was, Palm’s memory management wasn’t. Palm called anything that had ROM or RAM a “card.” On early models like this one, they were literal physical cards that could be replaced; the upgrade card here has both a Toshiba 512K pseudo-static RAM chip and Palm OS 1.0 in ROM, also 512K. The original concept was to have separate ROM and RAM cards (remember this for later), and the OS supported it, but the units shipped with unified cards.

Since databases were installed in memory and applications were executed in-place, most of the memory was thus earmarked as storage; only a small amount was available as a work area for the operating system and the currently running application. Although system overhead limited the size of any single allocation to slightly less than 64K, it didn’t matter because in Palm OS 1.0, the amount of “dynamic memory” was exactly 32K. That amount was immediately cut down further by system globals like the screen buffer and UI state (2.5K), plus the operating system’s own dynamic allocations (15K). Finally, after the 2.5K for your application stack was allocated, your application would have 12K left for everything else you need to do. Don’t spend it all in one place.

By the end of the 1996 Christmas season, the capable yet still relatively inexpensive Pilot 1000 and 5000 held over 70 percent of the US handheld computer market, with the DOS-based HP LX series coming in at a distant second. Software developers had taken an interest as well, and over a hundred compatible applications were available. Palm was further buoyed by the poor showing of the first Windows CE 1.0 devices, whose clamshell form factor polarized reviewers, and its interface and performance attracted some of the same complaints the Zoomer did. Unfortunately, the Pilot’s strong sales also attracted the attention of the Pilot Pen Corporation, who promptly asserted its trademark and sued.

So for the follow-up, the Pilot at last became the PalmPilot. In March 1997, Palm unveiled the PalmPilot Personal (512K for $299) and Professional (1MB for $399) devices with the new Palm OS 2.0, acting as direct replacements for the 1000 and 5000. Both devices had the same architecture and CPU, but they got a new backlit display and updated onboard applications. For the Professional, the new operating system also added TCP/IP support (over an optional dialup modem) and a 64K dynamic memory space (though the networking consumed half).

As a courtesy to first-generation owners, Palm furnished $199 memory card upgrade kits with 1MB of RAM and the Palm OS 2.0 ROM, essentially making them Professionals. The upgrade could not do the same for the backlight, however, which caused some angry Pilot owners to demand trade-ins (Palm politely refused), though the devices were nevertheless another hit with reviewers and buyers.

2Much 4 3Com

What wasn’t a hit anymore was USR’s core modem line as modems became commodity products in a race to the bottom. Unbeknownst to Palm management, USR had been in merger talks for months with networking giant 3Com, and in June 1997 tied the knot for $7 billion. While 3Com CEO Eric Benhamou initially continued the hands-off approach to Palm, he did insist that the operating system be licensed. Dubinsky initially complied, setting up limited partnerships with Symbol, Qualcomm, IBM, and others, but Microsoft’s second attempt with Windows CE 2.0 in January 1998 demanded a bigger response.

Palm countered with the Palm III in March, again at $399 with the same backlit screen and CPU, but also a more streamlined case that eliminated the memory door and provided a hard screen cover. An upgradeable card still lurked within with 2MB of RAM and 2MB of flash for the new Palm OS 3.0, but the biggest update for the Palm III was an IrDA-compliant infrared port allowing users to exchange software and structured data (implemented internally as a serial port). Palm provided another $199 upgrade kit as well to Pilot and PalmPilot owners, but not only did it contain the 2MB/2MB card, it also had the IR LED and photodiode, along with a new memory door to accommodate them.

Palm OS 3.0’s support for beaming applications came as part of a new, dedicated Application Launcher, which replaced the pop-up launcher in 1.0 and 2.0. While most users noticed only the Launcher and the updated applications, programmers got a more generous 96K of dynamic memory and the ability to dynamically build UIs at runtime instead of having to pre-create them in resource files. The operating system also newly introduced the ability to store arbitrary data (“file streaming”) in Palm databases, which was more like how file I/O worked on desktop operating systems, and you were limited only by available capacity. Additionally, Palm OS 3.0 was the first version of the operating system to add support beyond a simple monochrome bitmapped display.

Despite the operating system improvements, however, the hardware was obviously aging. Hawkins determined that going toe to toe with Microsoft on traditional marks such as memory and processor speed would be fruitless, so Palm moved to a three-tiered strategy. Alongside the traditional III, Palm would develop a new “fashion statement” ultrathin device codenamed Razor and a “super duper” wirelessly networked Palm codenamed Blue Sky. Razor became the very popular Palm V (Will Smith, writing for Ars, loved it) in February 1999, but turmoil at Palm greatly delayed Blue Sky to May 1999, which launched as the Palm VII.

The Palm VII was then the most expensive Palm device at $599 (in 2024, about $1,100), not counting the wireless subscription, which cost a minimum of $10 a month depending on your data use (and some beta testers incurred huge bills). The price was also even more unattractive given that it still had a 16MHz DragonBall (the die-shrunk DragonBall EZ 68EZ328) and just 2MB of RAM.

Nevertheless, it was years ahead of its time. While the Qualcomm pdQ phone—effectively a Palm III in a flip-phone case using Qualcomm’s CDMA technology—had been announced back in September 1998, the Sprint PCS network took months to upgrade, and the device wasn’t available until almost December 1999. But if you lived in one of the Palm VII’s test markets, you could get one “now.” Instead of a wireless modem costing hundreds of dollars connected to a laptop costing thousands, you finally had at least a portion of the Internet in the, er, palm of your hand. Beating the pdQ to market by months, the Palm VII was thus the first Internet-enabled Palm device.

Initially, the Palm VII was limited to just three rollouts on the US East Coast and did not go nationwide until about 10 months later. The official Palm wireless service was Palm.Net, which Hawkins and product manager Joe Sipher had originally planned as a low-cost convenience but was now something the cash-strapped 3Com saw as a potential revenue stream. By the time Palm.Net was available nationally, the three plans shown here offered data caps of between 50K (yes, kilobytes) and 300K a month, with each additional kilobyte costing 20 cents. The 300K option, at a cool $40 a pop, got you an estimated 480 “transactions.”

Palm.Net operated on top of the Mobitex network, the same as the recently introduced BlackBerry, which was a packet-switched narrowband wireless service running at about 8 kilobits per second (though practical throughput was usually around half that). Connectivity for the domestic Palm.Net service was primarily provided by BellSouth, connecting back to 3Com’s servers in Silicon Valley. At that time, BellSouth covered about 93 percent of the urban United States.

The communications hardware is based on the Lucent POMP-15 (“Peace of Mind Processor”), incorporating a 16-bit DSP, analog-digital converters, RAM, and, in this variant, a small amount of flash memory. It is only powered on when the side antenna is raised. Despite relatively low standby power usage, the POMP’s draw during active communication still required its own rechargeable internal battery to power it, which is trickle-charged from the AA batteries. This rechargeable battery is now dead in my unit, of course, so it cannot properly communicate.

Mobitex networks operate over intelligent base stations (MSNs, or Mobitex Switching Nodes) that service individual cells to which subscriber devices connect. Although Mobitex-based providers remain in operation today primarily for high-reliability paging service (over the 900 MHz band in the United States, which provides good non-line-of-sight operation), the MSN here shown on the screen was likely cached in the POMP’s flash. The device provides its MAN (Mobitex Access Number) or PMAN (personal MAN) and a password; the MAN serves to identify the device on the network, much like a modern IMSI.

There was no way a 2MB unit with roughly 4Kbps bandwidth could handle the web, even in 1999. (Plus, at the rates 3Com was charging, just trying to do so would have quickly bankrupted any unfortunate purchaser.) Instead, Palm developed a “query” architecture oriented around what it called “web clippings.” Rather than simply allowing browsing, Palm provided stub applications that contained forms for obtaining weather, headlines, and sports scores, or the location of the nearest courier drop-off—each one being what the billing table called a “transaction.” All transactions were managed by a hidden application in Palm OS 3.2 called Clipper.

In this scheme, Clipper-powered Palm Query Applications communicated over Mobitex back to the Palm.Net servers, using compression and UDP to reduce overhead further (the network itself provided the delivery guarantee), and the servers acted as proxies, running the queries against partner sites and returning results. Palm-friendly content marked with a special tag was compressed and sent more or less as-was, but other content was stripped of images, scripts, Java, and frames before transmission.

Compare this to the Qualcomm pdQ, which was planned in both an 800 MHz cdmaOne digital/analog version and a 1900 MHz PCS all-digital version, but the company only shipped the latter. cdmaOne could run up to 14.4kbps, and later more, which was noticeably faster than Mobitex. But its bandwidth was similarly costly, and the on-device software unwisely attempted to browse PC-oriented sites directly, which made for an expensive and slow experience. It sold briefly and poorly before Kyocera bought Qualcomm’s phone division at the end of December.

The VII’s communications with its proxy were encrypted using elliptic curve cryptography (an early commercial implementation by Certicom) rather than regular SSL or TLS 1.0; crude location information came from knowing the MSN the device was connected to, down to a few city blocks, and messaging operated over the same infrastructure. Sadly, the Palm.Net proxies have long since been decommissioned, so none of these applications can retrieve anything anymore.

Handspring turns over, and Palm comes apart

The Palm VII’s delay was because Donna Dubinsky, Jeff Hawkins, and Ed Colligan had since left, taking loyal engineers with them. The ailing 3Com had slashed Palm’s budget, and Benhamou emphatically refused to spin Palm off, believing it would endanger both companies. Dubinsky resigned on the spot in July 1998, with Hawkins following shortly after, and when Benhamou refused to name Colligan as CEO after being irked by a grassroots employee campaign, Colligan left as well a few weeks later. Hawkins would have preferred not to start from scratch, however, and, true to his word, Benhamou was still willing to license the Palm OS to the new company: Handspring.

Handspring distinguished its units not only by being the first Palm devices to HotSync over USB but also because of its innovative Springboard slot, which was the Palm ecosystem’s first expansion mechanism. Hawkins had reconsidered his work on the Palm VII and believed that the next step should actually be full telephony, but the large incumbent wireless carriers had little interest in working with a new company.

Springboard modules solved this problem. Handspring could still sell “regular” Palm devices, but they could be upgraded later, they didn’t have to commit to any particular mobile technology or carrier up front, and the slot could be used for any variety of other features. Every Visor made shipped with an onboard microphone to facilitate using them as phones. Additionally, recall that the OS could support two ROM or RAM cards at once, a holdover from the original plans for the first Pilots; this capability was exploited to enable modules to carry their own onboard software.

The first Handsprings, named “Visors” by Hawkins’ daughter, short for “advisor,” were announced in September 1999. The low-end black Visor Solo ($149) and Visor ($179) were identical in specification to the 2MB Palm III, which ran Handspring’s custom Palm OS 3.1H; the Solo shipped without a HotSync cradle for users without their own computer. 3.1H supported the new Springboard hardware and included an updated datebook and calculator and a graphical world clock. On the high end, the Visor Deluxe ($249) shown below came in multiple translucent colors—after all, the trendsetting iMac G3 had come out the year before—and directly competed with the Palm Vx, including the same upgraded 20MHz DragonBall CPU and 8MB of RAM.

Springboard modules ranged from relatively simple devices like flash memory and software ROM cartridges all the way to mobile communications, Ethernet, GPS, MP3 players and cameras. Modules were dynamic and hot-swappable. On inserting a module, if a setup application was present in the module, it was copied to main memory and run to install any needed patches or operating system libraries (and when removed, the copy of the setup application was called again to remove those tweaks and then purged). Modules could also designate “welcome” applications that ran on insertion after setup, and all applications on the card would appear automatically in the Launcher and terminate gracefully on removal. Thus, under most circumstances, the user wouldn’t need to manually install drivers to use a given module, and on-board software was installed and removed transparently without needing to reset the Visor itself.

On the hardware side, the Visor passed two chip select lines in the 68-pin slot to the module, which controlled two memory-mapped I/O ranges of up to 16MB each. The slot also carried the 68000 address and data busses as well as interrupt request lines, power and ground, a low-battery signal, and audio lines from the on-device microphone. Modules contained metadata with manufacturer and product name (which had to be registered with Handspring) on their internal ROMs, and they could interrupt and wake the Visor or alternatively enter low-power modes to save energy. To make room for the slot, the IrDA port on the Visors was moved to the side.

Handspring had a disastrous initial few months, not only because of profound technical problems with its web store but also because its Visor press announcements were swallowed up by the big news that 3Com would spin Palm off after all. Still, its units became market leaders; the Visor Platinum ($299) and Prism ($449) in October 2000, powered by the new 33MHz DragonBall VZ, were initially the fastest Palm devices available. Confronted with Handspring’s continued inroads and the ever-present threat that Microsoft might strike it big with the next iteration of Pocket PC, the newly independent Palm decided to announce its Palm V successors early: the m500 and m505.

Repaying accumulated technical debt, the m500 series were the first first-party Palms to support USB HotSync (using the new Universal Connector) and the first first-party devices to have an expansion slot—using SecureDigital/MultiMediaCards, which also supported a limited number of SDIO cards. Both devices came with 8MB of RAM and the new PalmOS 4.0, which could store files on and run applications from SD/MMC. They also came with rechargeable Li-ion batteries and a green charge/alert light, but the m505 also featured a backlit 16-bit color screen. Palm rushed the m500 and m505 into stores in April 2001 for $399 and $499, respectively.

And hey, that’s where I got into Palm myself, buying a brand-new M505 for medical school. This is my original device; the silk-screened m505 wore off the case long ago, and it needed a new battery, but now successfully refurbished, it still works splendidly. Palm devices were becoming popular in medicine then, and I used mine heavily for looking up medications, taking quick notes, doing calculations, and, yes, playing games surreptitiously on rounds and between calls. Overclocking apps (up to 66 MHz) were very popular, even considering the toll it took on battery life. The Pocket PC folks sat alone and unloved while us Palmies signed out by beaming data back and forth and exchanged games and utilities in the cafeteria.

Palm OS 4.0’s support for SD/MMC involved some fancy footwork. Unlike Springboard, where the module’s contents were mapped into the processor’s address space and thus directly accessible, SD/MMC is a storage medium, the same problem that confronted clones like the TRGpro (Compact Flash) and early Sony CLIÉs (MemoryStick). These earlier devices could only use cards as sidecar storage. Palm’s solution was to transparently copy programs from the SD card into main memory, run them as usual and purge them on exit, a slightly slower process, but one that worked mostly seamlessly except for the inevitable brief startup delay. (Plus, almost all my old files survived on the card, which is more than I can say for the main memory after the battery died.) If a card had a specially named startup program, it would be immediately copied into memory on insertion and automatically executed as long as the Palm was not locked, facilitating autostartable game and application cards.

Also notable about Palm’s SD/MMC implementation was multiple card support, though this wasn’t leveraged much, and FAT compatibility (via the new Virtual File System API). Using FAT as the file system meant files could be read and written as “regular files” on SD/MMC cards instead of having to wrap them up as databases, and cards could be interchanged with desktop computers.

Palm OS 4.0 also continued the improved memory management first introduced in 3.5, sizing the dynamic heap based on the amount of memory in the device rather than enforcing a fixed amount on all devices. Models with at least 2MB of RAM now supported 128K of dynamic memory, and units with at least 4MB, including the m500 series, supported 256K. After the system took its own working allocations, applications had up to 56K and 184K available, respectively, on most units. It still wasn’t much, but it was certainly an improvement.

The m505 wasn’t a perfect device, mind you. Its backlight wasn’t great, it used a lot of battery power, and everyone wanted more storage—all problems addressed by the successor m515. Meanwhile, by this time, the PDA market had exploded and had its own peripherals and accessories and shops specializing in them. Run down to your local CompUSA or Circuit City, and you could pick up a foldable keyboard, utility styluses (ironically, the best stylus I ever used was made by the Pilot Pen Corporation itself, with an actual ballpoint pen inside), cases, screen protectors, backup and game software, and more. For something originally intended as an accessory, we sure were using them as devices in their own right by then.

Send in (some of) the clones

Post-spinoff, 3Com CEO Eric Benhamou’s liberal Palm licensing policy continued and even broadened. Handspring notwithstanding, some of the most inventive Palm devices weren’t ever made by Palm.

No discussion of Palm clones can be considered complete without remarking upon the Sony CLIÉ series, which Sony first introduced with the PEG-S300 in Japan in September 2000. It used a 16MHz DragonBall with 8MB of RAM running 3.5 on a 16-grey display, adding a unique jog-dial scroll wheel and support for Sony’s Memory Stick, both of which became trademarks of the line. The Memory Stick slot was ostensibly to serve as a general-purpose expansion slot, but it could also provide up to an additional 8MB as storage (though databases and apps could not yet be run from it). It, too, had a USB cradle and sold for $399.

Sony was probably the longest-lived clone manufacturer and almost certainly the biggest seller, producing devices with on-board cameras and audio players in daring form factors, some of them even sporting their own keyboards. TRG also deserves a mention not only for developing the first Compact Flash-capable Palm (the July 2000 TRGpro) that could even accommodate IBM MicroDrives but also the HandEra 330 in April 2001, the first device with a 240×320 1.5x density screen and virtual on-screen Graffiti input, plus multiple card storage options and a jog dial. (Unfortunately, it also had compatibility issues and slow tap response, and the device was criticized by reviewers as clumsy.)

However, two clone devices particularly stand out to me and were the only classic Palm devices ever made of their kinds. One was a laptop, and one was a watch.

Although the 2000 Palm IPO under then-CEO Carl Yankowski was very successful, Yankowski was a controversial figure within the company, and Benhamou suffered his own share of criticism at 3Com for entering handheld computing in the first place. Though Benhamou was removed as CEO of 3Com in January 2001, he didn’t have long to wait for his new job; Yankowski was forced out from Palm in November after Benhamou convinced Palm’s board of directors to double down on licensing the operating system and split the company.

Benhamou took over as Palm CEO, and in January 2002, Palm announced the new PalmSource subsidiary that would own and license the Palm OS source code. PalmSource spun off completely in October 2003 and Palm renamed itself palmOne, incorporating the now ailing Handspring, which it bought in June 2003 (bringing Hawkins, Dubinsky, and Colligan back to their original company). Benhamou remained as chairman of both halves of Palm.

Besides servicing existing licensees, new ones were courted by PalmSource, including edutech company AlphaSmart. AlphaSmart was already known as a manufacturer of battery-powered portable word processing devices where text could be typed into units and then “sent” (over a keyboard port) to a computer, initially Macs via Apple Desktop Bus, to prep for style and publication. Originally running a custom minimal OS using the Motorola 68HC11, they were famous for their light weight, durability, and long battery life, and they became popular in schools and with journalists. However, AlphaSmart was already branching out to more general-purpose machines; the 3000 could run its own custom applets. From there, it was a simple step to graft in a DragonBall instead, and AlphaSmart became a new licensee of the Palm OS for the June 2002 Dana.

The Dana was essentially the only true Palm OS laptop, running Palm OS 4.1 on a 33MHz DragonBall VZ. The first revision provided 8MB of memory in the same basic form factor as previous AlphaSmart devices but using a grayscale 560×160 backlit touchscreen. This screen could run regular Palm OS applications “pillarboxed” in the middle or Dana-aware applications on the full width, such as the built-in AlphaWrite word processor (a licensed, reworked version of Blue Nomad Wordsmith). The keyboard, like most AlphaSmarts, was excellent, and the device could run off a rechargeable battery or AA cells. My mother used one to take notes in Bible study largely because it was small, light, and fast, pushing the text to Microsoft Word on her iBook G4 when she got home. Besides providing the “keyboard” connection, any USB cable could trickle-charge an installed rechargeable battery (as well as the AC adapter for quicker charges) and also served as the unit’s HotSync “cradle.”

In 2003, AlphaSmart released the Dana wireless [sic] model, which upgraded the ROM, doubled the memory (16MB), and thus doubled the dynamic heap, upgraded the SD slots to support SDIO, and added built-in 802.11b WiFi. DanaWeb, a complete web browser package, came on CD and could be optionally installed. While slow and prone to freezing on modern pages (if it could access them at all, not having any support for encryption), it supported primitive JavaScript, images, and the full width of the display, and it was one of the most capable Internet browsers available for any 68K-based Palm device. But don’t even think about using it without overclocking the CPU.

While the Dana series was AlphaSmart’s only family of Palm devices, the 2004 Neo and 2007 Neo 2 used the same basic hardware and CPU, though running a bespoke operating system once again. AlphaSmart was bought out by Renaissance Learning in 2005, and the brand name was later retired.

Similarly, there was only ever one Palm OS smartwatch, and it also wasn’t from Palm. Watch company Fossil had been experimenting with Palm-based smartwatches as far back as 1999 and even worked on a separate watch using Microsoft’s contemporary SPOT radio data service. Despite initial positive buzz, however, it took until January 2005 for the company to get the watch small enough and light enough and able to manufacture it reliably. It uses a folding stylus that clips into the wristband, though its size makes it easy to lose, and only one spare came in the box, as well as more typical side watch buttons. For Graffiti purposes, the entire screen served as the writing area, and the Launcher could also be operated with the buttons.

The Wrist PDA came in a number of price points, but all of them were expensive, and it offered no connectivity options other than USB HotSync and IrDA (though this can be worked around). Likewise, while the Wrist was one of the fastest 68K Palms, its downclocked DragonBall Super VZ compared poorly with the newest Palms introduced around the same time, and it only had 8MB of RAM. On top of all that, battery life was poor, and the watch body wasn’t even water-resistant. The Wrist PDA ended up a sales flop, and Fossil canceled the line in February 2006.

The Palm connects to the ARM

But what were those newest Palms? In 2002, PalmSource unveiled Palm OS 5, the next major release of the classic Palm operating system. Unlike every version before it, however, Palm OS 5 ran on ARM processors, a totally new architecture for Palm devices, and completely replaced the old 68K KADAK kernel with its own in-house MCK kernel. It additionally doubled the maximum screen resolution to 320×320 (later even more) and greatly improved memory management, substantially increasing the dynamic heap and reducing contention, all while making the operating system more modular.

Palm 5 devices also had the same problem the first Power Macs did—they had to run existing software, which was 68K—and they solved it the same way, using an on-device emulator. In addition to emulating 68K instructions, the Palm Application Compatibility Environment (PACE) intercepted A-line traps and operating system calls, marshaled their parameters, handled the endian switch, and ran the call as native code. PACE, however, was the only supported means to run apps, which meant there was no documented way to create an entirely ARM-native application. (This is, in fact, technically possible but subject to notable limitations.)

Applications with speed-sensitive sections could run small bits of native ARM code called “ARMlets” with various restrictions of their own, making video, music, and gaming much more fluid, but most apps nevertheless still had significant portions that were emulated. As such, for compatibility reasons, there was still no memory protection, and because earlier Palm OSes didn’t support user multithreading, Palm 5 didn’t either, even though KADAK’s contractual requirements were now gone.

The first ARM Palm was the November 2002 Tungsten T, initially named the m550 during development, and it retailed for $499 (about $880 today). It came with 16MB of RAM (a generous 823K of which was dynamic heap), a 144 MHz TI OMAP1510 CPU, built-in Bluetooth and microphone, and a 320×320 color screen with a slider Graffiti area. Other than the smartphone Tungsten W, which was one of the last to use the 33 MHz DragonBall VZ, the Tungsten series represented the top of the line in Palm performance.

Many aficionados will point to the October 2004 Tungsten T5 as the zenith of the series. It boasted a 416 MHz Intel XScale PXA270 “Bulverde” CPU (overclockable, too), a full sliderless 320×480 screen, and 256MB of non-volatile flash for storage, meaning it could survive a dead battery (working memory was backed with 16MB of conventional RAM) and had enough space to even act as a USB flash drive—for just $399. Unfortunately, Palm hadn’t quite worked the bugs out of 5.4.5’s new Non-Volatile File System at launch, leading to compatibility problems and inefficient usage; the T5 still didn’t have WiFi built-in (an SDIO card option was available); and it used the new and incompatible Athena connector for charging and syncing.

Instead, I submit that the best all-around Tungsten was this one, originally dubbed the Tungsten XX. In May 2005, palmOne bought back PalmSource’s share in the Palm trademark and reverted its name back to Palm. Instead of calling it a Tungsten, the new Palm changed the name to the T|X, introducing it in October as one of the first devices under the “new old” name. While comparatively pedestrian, with a 312 MHz PXA270 (overclockable to 520 MHz) and “just” 128MB of flash, the NVFS bugs were largely fixed in 5.4.9, and it sported 32MB of conventional RAM and built-in Wi-Fi and Bluetooth. Plus, it had the same superb screen, played music and video from the internal memory or SD card, and sold for $299. The only thing I don’t like about it is that the battery pack is soldered in and a bit harder to replace than in some other units.

Although the Tungstens and the TX were intended to cater to the upper market, Palm had not forgotten about consumer devices. Strangely, this was a market that Sony by now had largely abandoned. Although Sony was one of the first to add a color camera to its line (such as the 2002 PEG-NR70V) and offered music and media playback from MemorySticks, its market interest waned in the ARM era.

The 2004 PEG-TH55 had the full 320×480 screen but only ran Sony’s custom Handheld Engine ARM CPU at 123 MHz, and the last CLIÉ PEG-VZ90 was almost the same device in minitablet form and sold only in Japan. Of other notable consumer ARM Palms, the November 2003 Tapwave Zodiac ran a custom version of Palm 5.2 on a 200 MHz Motorola DragonBall i.MX1 with 10MB of RAM and an onboard ATI GPU for gaming. It lacked a camera, but it could play music and media and offered a wide variety of games like Doom II, Duke Nukem Mobile, and Madden NFL 2005 on SD cards. It unfortunately competed more or less directly with the PlayStation Portable and Nintendo DS and ended up exiting the market in July 2005.

Palm’s consumer budget line, the Zire series, was a bit less prosaic. The original 2002 Zire was Palm’s first device under $100, but it got there by offering just 2MB of RAM, monochrome, and a 16 MHz DragonBall EZ— basically a Palm III in a new case with Palm OS 4. The Zire 21 added a 126 MHz OMAP311, but didn’t upgrade anything else. The line didn’t really come into its own until the Zire 71 in April 2003, which had a 144 MHz OMAP310, 16MB of RAM, a 320×320 color screen, an SD slot (Bluetooth and WiFi optional via SDIO), and a 640×480 VGA camera accessed by sliding the screen up—as long as the flex cable didn’t snap. It sold for $299 and could play music with the built-in RealPlayer app from an SD card.

However, for my money (literally), the best Zire was my second Palm, the 2004 Zire 72. It wasn’t perfect, either; the screen wasn’t quite as bright, the camera didn’t have a cover and could get scratched, and the purple soft-touch coating unattractively flaked off after a while (see the picture at the beginning of this article for how terrible it got with mine). The problem was so bad that Palm ended up making a “special edition” in silver without the coating. But it did everything the Z71 did and more. It had a 312 MHz PXA270 (overclockable to 520 MHz), 32MB of RAM, double the camera resolution at 1280×960, voice recording, video recording to SD card—with sound!—and built-in Bluetooth networking. If you got the optional hard case, it was a fairly durable device with a flip face and lens cover that fit in your pocket. And the Z72 sold for $299, too (the Z71 was reduced to $249).

The Z72 was such a good all-around device that I continued to use my Z72 even after I got an iPhone 2G and 3G, largely because the Z72 could record video and still had a better selection of medical applications. Not until the 2009 iPhone 3GS could iOS devices take video, and it was a while until the app selection caught up. A lot of old family videos and pictures were on this thing, and since they were on the SD card, I still have them. Plus, the Z72 was powerful and cheap enough that I’ve since acquired several more (such as the much-better-condition ones here) that I use for various tasks like controlling the house lights.

Palm’s last call

But the last era of classic Palms—the smartphone era—was the one that ended it, and the last classic Palm (as well as most of the webOS Palm devices that came after) was a smartphone, too. However, the Palm smartphone story actually starts with Handspring.

Recall that Handspring’s idea with the Springboard slot was to add mobile connectivity to its Visor devices, and every Visor shipped with a microphone built in to facilitate the upgrade. In 2001, Handspring shipped the VisorPhone card, a dual-band GSM device. It was as easy to install as Jeff Hawkins had intended, and it came with a full suite of phone apps and a browser built in. But it was bulky, and it required an additional battery that dangled off the back (though the cradle could charge it). It also had variable call quality, and the understandably non-oleophobic PDA screen also didn’t always reject ear presses. Plus, it cost $299 on top of the PDA you had to plug it into.

In 2002, Handspring tried again with the $399 Treo 180, the first of its new intended line of mobile phones. Essentially a Visor Pro internally with a 33 MHz DragonBall VZ, 3.5.2H and 16MB of RAM, the Treo 180 also did away with the Springboard slot and incorporated the GSM modem and software into the device itself. It came with a flip cover and either a thumb keyboard or (the 180g) a Graffiti area more like a typical Palm PDA. The Treo went color with the 270, CDMA with the 300 (a 270 otherwise), and then ARM with the 600, using the same 144 MHz OMAP1510 as the Tungsten T but with 32MB of RAM, a thumb keyboard, a 160×160 screen, an SD card slot, and a 0.3-megapixel camera.

Treos were obviously not the only Palm phones made. Besides the Qualcomm pdQ and the successor Kyocera QCP models, other clone vendors made mobile phones based on the Palm OS, most notably Samsung. (The CDMA Samsung SPH-i500 was particularly notorious for being able to receive SMS messages but unable to send them.) However, the Treos rapidly became popular, and of all the Palm OS phones, they were ultimately the longest-lived and most prominent after Palm bought Handspring out, making the 600 the first “first-party” Palm smartphone.

The November 2004 Treo 650, however, was the basis for nearly every classic Palm phone that followed. It used the 600 form factor but upgraded to a 312 MHz (overclockable) Intel XScale PXA272 CPU, with 32MB of non-volatile flash and 16MB SDRAM on-package, an improved keyboard, a 320×320 screen, a better-quality 0.3-megapixel camera sensor, and built-in Bluetooth. It came in both quad-band GSM and CDMA versions and sold for $699 unlocked.

The 650 had some of the same NVFS teething problems initially as the T5, but it became an enduringly popular device (even turning up in music videos, which Palm included a clip from on the T|X) and Palm sold it in various forms until 2008. Palm used the 650, with upgrades, to create the 2006 Treo 680 (64MB flash, 32MB RAM, a larger keyboard, GSM/GPRS/EDGE only), the 700p (128MB flash, 1.3MP camera, Bluetooth 1.2, CDMA/EVDO only) and the 2007 755p (CDMA/EVDO only, sleeker case). The 650 was even later knocked off in China as the P850, an unofficial budget device.

In October 2007, Palm introduced the last Palm OS-based Treo, internally the Treo 690, although it wasn’t called that. Instead, this small, colorful phone was dubbed the Centro, initially sold as CDMA/EVDO-only on Sprint for $100 (on contract). Later, a GSM/GPRS/EDGE version was sold by various vendors, or you could get it unlocked for $299. It would be the last official device to run Palm OS 5.

The Centro was a significantly altered design. It still had a 320×320 screen, but it was smaller, with reduced phone buttons and keyboard, and the CPU was still 312 MHz but using the earlier PXA270 with off-package flash and SDRAM. While it maintained the same 1.3 MP camera and Bluetooth as the later Treos, the first version reverted to only 64MB of NVFS storage (the second revision upgraded it to 128MB). It had no SD card slot and no SDIO support, though it did support microSD storage under the exceptionally tightly fitting battery door. Like all Treos, the built-in browser on both devices was intended only for cellular data and doesn’t work without a mobile network connection. Both devices can take video and stills.

The Centro’s case color generally reflected the service it was sold on. The first Sprint devices were a cheerful red (as well as black and pink), and the October 2008 upgrade added green and rose. For AT&T, it was sold in black, white, and electric blue, while Verizon was dark blue; in other countries, Telstra sold a white unit in Australia, and in Canada, Rogers Wireless sold it in dark blue and later Bell Mobility in black. The June 2008 unlocked quad-band GSM version was also initially sold in white, but the last unlocked GSM Centro shown here once again came in stylish cherry red.

While Palm discontinued the other Palm-based Treos in the summer of 2008, the Centro’s low cost and appealing pocket size made it a minor hit with consumers, and for a period of time, it was the second-ranked US smartphone by traffic count. (It’s certainly my favorite Palm phone.) Several million were eventually sold, and it continued to turn a solid profit for Palm while the company labored to create the first version of webOS and the Palm Pre. Although the Centro was clearly less sophisticated than the iPhone and early Android devices, it was also substantially cheaper, still ran Palm PDA apps and could do most basic smartphone tasks. With the Pre’s introduction in June 2009, the Centro was quietly retired—as was the operating system that started it all.

With webOS phones, you could always Colligan

webOS solved two big problems for Palm: First, it gave the company a next-generation mobile operating system (and with the Classic emulator, one that could still run older Palm OS apps), and second, it moved development of the core operating system back to Palm itself. While Palm had negotiated an agreement in 2006 with ACCESS, PalmSource’s 2005 buyer, that Palm would have perpetual rights to the Palm OS 5 “Garnet” source code and the ability to modify it, the arrangement didn’t cover any future OS. Though Palm had also sold Windows Mobile-based (the horror!) Treos using similar hardware, with webOS, Palm no longer had to depend on any external company to decide its software future.

Meanwhile, PalmSource had developed Cobalt as Palm OS Garnet’s intended successor, incorporating technologies it acquired from the defunct Be, Inc. and its BeOS. Despite being announced in January 2004, however, neither Palm nor any other manufacturer found it suitable to make a device that ran it or its Linux-based successor. (Palm’s pre-webOS Linux device, the doomed “accessory laptop” Palm Foleo, ran a custom Linux build.) The Linux-based successor to Cobalt became known as the Access Linux Platform and appeared on some Japanese mobile devices before being canceled in 2010.

Although the webOS era had a strong start, we all know what happened to Palm after that—the HP acquisition and its abrupt cancellation and zombification under TCL. Today’s shambling corporate corpse of Palm doesn’t even sell any smartphones, merely earpods and a small Android-based “companion device.” Just like video killed the radio star, the smartphone killed the PDA and a whole lot of fun gadgets with it, plus the very soul of the company that arguably did the most to advance handheld computing. Whatever device will replace the smartphone, well, we’ll probably never see it coming.

But to this day, I have a lot more fun on my Zire 72 than my wife has on her iPhone. Just keep that between us.