What’s Happening in webOSland

2 BY devrel

What’s happening in webOSland is a collection of interesting links to articles and conversations about webOS and webOS development. If you have something you think we might want to include in future postings, you can send it to us at pdn@palm.com or via twitter to @webosdev

Palm Engineer Demos the Wonders of webOS at the Sprint Developer Conference

2 BY devrel

Until now, we’ve been pretty nontechie here, but what Palm Engineer Matt Hornyak did during his talk at the Sprint Developer Conference today was so cool that we have to get really technical here, at least for today.

Matt is the lead engineer on the webOS phone app. He also wrote Clock, which ships with Pre. In front of the gathered masses at the Sprint conference – somewhere around 500 of them – he went deep inside Clock. Matt explained his motivation in writing it and then described the design and coding of it.

All great stuff, but he saved the best for last. Wanting a way to change the length of the snooze alarm in the Clock app, Matt cooked up the code, added it to the app, and – voila – Clock had snooze control, running on the device I might add. And all this in about five minutes, in front of a live audience.

Here is the code he used for the control, with Matt’s annotations (in boldface) about what each section does. You might want to take a look at Clock and try adding this yourself, although if you’re not really experienced with JavaScript and Mojo yet, you might not want to make this the first thing you try.

If this is over your head, hang in there. We’re collaborating with Matt on an article about Clock that will include more detailed instructions on how to add the snooze feature. Consider this a sneak preview.

More from the Sprint conference later this week. Check back, ok? Out for now.

Listing 1. Adds the new widget, and the borders around it.

Index: app/views/settings/settings-scene.html
— app/views/settings/settings-scene.html    trunk)
+++ app/views/settings/settings-scene.html    (demo)    @@ -33,5 +33,16 @@
+    <div class=”palm-group”>
+        <div class=”palm-group-title”>
+            <span x-mojo-loc=”>snooze</span>
+        </div>
+        <div class=”palm-list”>
+             <div class=”palm-row single”>
+                <div id=”snoozeduration” x-mojo-element=”ListSelector”></div>
+            </div>
+        </div>
+    </div>

Listing 2. Changes settings assistant to set up new widget, and respond to events from it.

Index: app/controllers/settings-assistant.js

— app/controllers/settings-assistant.js    trunk)
+++ app/controllers/settings-assistant.js    demo
@@ -1,6 +1,26 @@
/* Copyright 2009 Palm, Inc.  All rights reserved. */

var SettingsAssistant = Class.create({
+    // values for snooze duration listselector
+    snoozeDurationChoices: [
+        {
+            label: $L("5 min."),
+            value: 5
+        },
+        {
+            label: $L("10 min."),
+            value: 10
+        },
+        {
+            label: $L("15 min."),
+            value: 15
+        },
+        {
+            label: $L("8 hrs."),
+            value: 480
+        },
+    ],
initialize: function(settings, themes, onThemeChange) {
this.appController = Mojo.Controller.getAppController();

@@ -14,6 +34,7 @@

this.onKeyPress = this.onKeyPress.bind(this);
+        this.onSnoozeDurationChange = this.onSnoozeDurationChange.bind(this); // event handler for snooze duration list handler

this.easterString = “”;

@@ -22,8 +43,12 @@
// VERY IMPORTANT: UI for ringer switch has OPPOSITE MEANING of variable
// it’s reversed here for display and must be reversed back when saving
initializeSettings: function() {
-        this.settingsModel = { };
-        this.settingsModel.ringerSwitchObeyed = !(this.settings.ringerSwitchObeyedGet());
+        this.settingsModel = {
+            ringerSwitchObeyed: !(this.settings.ringerSwitchObeyedGet()),
+            snoozeDuration: this.settings.snoozeDurationGet() // load setting for snooze duration into scene’s model
+        }

setup: function() {
@@ -50,6 +75,15 @@

this.controller.get(‘theme_set’).observe(Mojo.Event.tap, this.onThemeSelect);

+        this.controller.setupWidget(‘snoozeduration’, { // setup snooze duration’s listselector widget
+            label: $L(‘length’),
+            choices: this.snoozeDurationChoices,
+            modelProperty: ‘snoozeDuration’,
+            labelPlacement: Mojo.Widget.labelPlacementLeft
+        }, this.settingsModel);
+        this.controller.listen(‘snoozeduration’, Mojo.Event.propertyChange, this.onSnoozeDurationChange);
this.controller.listen(this.controller.sceneElement, Mojo.Event.keypress, this.onKeyPress);

@@ -74,6 +108,10 @@

+    onSnoozeDurationChange: function() { // respond to events on list selector widget
+        this.settings.snoozeDurationSet(this.settingsModel.snoozeDuration);
+    },
themeUpdate: function() {
var theme = this.themes.getCurrentTheme();
this.controller.get(‘theme_name’).textContent = this.themes.getNicename(theme.name);

****end of framework-specific code; the rest is app-specific

Listing 3. Changes settings model to get/save snooze length.
Index: app/models/settings.js
— app/models/settings.js    (trunk)
+++ app/models/settings.js    (demo)
@@ -36,7 +36,8 @@
timePickerInterval: 5,
dashboardHide: false,
ringerSwitchObeyed: false,
-            initialized: true
+            initialized: true,
+            snoozeDuration: 5

@@ -72,9 +73,18 @@

ringerSwitchObeyedGet: function() {
return this.values.ringerSwitchObeyed;
-    }
+    },

+    snoozeDurationGet: function() {
+        return this.values.snoozeDuration || 5
+    },
+    snoozeDurationSet: function(value) {
+        this.values.snoozeDuration = value;
+        this.save();
+    },

Settings.kCookieKey = “settings”;

Listing 4. Changes alarm model to have adjustable snooze time.
Index: app/models/alarm.js
— app/models/alarm.js    (trunk)
+++ app/models/alarm.js    (demo)
@@ -341,12 +341,19 @@

// snooze this alarm.  pass true to indicate that it was snoozed by another popup opening
-    snooze: function(alarmInterrupted) {
+    snooze: function(alarmInterrupted, duration) {
var newParams = Alarm.kAlarmLaunchParams.evalJSON();
newParams.params.id = this.id;
if (alarmInterrupted) {
newParams.params.alarmInterrupted = true;
+        if (duration) {
+            duration = “00:” + duration + “:00″
+        } else {
+            duration = Alarm.kAlarmSnoozeDuration;
+        }
var newParamsJSON = Object.toJSON(newParams);
this.schedulerSetRequest = new Mojo.Service.Request(Alarm.kAlarmSchedulerUri, {
method: “set”,
@@ -355,7 +362,7 @@
“key”: Alarm.kAlarmSchedulerKeySnooze+this.id,
“uri”: Alarm.kAlarmLaunchUri,
“params”: newParamsJSON,
-                ”in”: (alarmInterrupted ? Alarm.kAlarmSnoozeInterruptedDuration : Alarm.kAlarmSnoozeDuration)
+                ”in”: (alarmInterrupted ? Alarm.kAlarmSnoozeInterruptedDuration : duration)
onSuccess: function(payload) {
// Mojo.Log.info(“Alarm: snooze succeeded”);

Listing 5. Changes ring notification to get snooze length.

Index: app/controllers/ring-assistant.js
— app/controllers/ring-assistant.js    (trunk)
+++ app/controllers/ring-assistant.js    (demo)
@@ -5,6 +5,7 @@
initialize: function(params){
this.appControl = Mojo.Controller.getAppController();
this.appAssistant = this.appControl.assistant;
+        this.settings = this.appAssistant.settings;

this.alarmOff = this.alarmOff.bindAsEventListener(this);
this.snooze = this.snooze.bindAsEventListener(this);
@@ -55,7 +58,7 @@
} else if (this.shortSnooze) {
this.alarm.snooze(true /* short snooze */);
} else {
-            this.alarm.snooze();
+            this.alarm.snooze(false /* not short snooze */, this.settings.snoozeDurationGet());

Complete Schedule of Palm Activities at Sprint DevCon

1 BY devrel

We’ve got a lot going on at the Sprint Developer Conference in Santa Clara next Monday, Tuesday, and Wednesday. You’ll have a lot of chances to hear from some of our experts and members of the webOS development community and to hang out with folks from Palm. Here’s an entire schedule of our participation:


9:30-10:30 AM Getting Started with Palm® webOS Apps, PART 1: The webOS Opportunity and Technical Overview. Ben and Dion with Mitch Allen, Palm Software CTO

Find out why webOS has generated so much excitement in both the web and mobile developer communities, and get a look under the hood at this game-changing OS from one of the engineers who led its development.

10:40-11:40 AM Getting Started with Palm® webOS Apps, PART 2: UI and app design details. Geoff Schuller, Palm UI, and Matthew Hornyak, Palm Engineering

Geoff Schuller will start things off with a review of general webOS app HI Guidelines. Then Geoff and Matt will present a deep dive into a sample application using the webOS Clock app. Geoff will review Clock’s UI design followed by Matt who will show how the Clock app was developed with examples from the Clock’s code.

12:15-1:15 PM Getting Started with Palm® webOS Apps, PART 3: Developer Showcase.

Ben and Dion with Chris Sepulveda (Pivotal Labs), Lawrence Davison (Mark/Space), Alex Pachikov (Evernote), and Dan Kurtz (SelfAware)
Four developers with apps in the Palm App Catalog demo their work and talk about how they got started with webOS. Hear about the challenges they encountered along the way and how they met them, and find out how each of them used skills developed writing for other environments to decrease the webOS learning curve.

1:25- 2:25 PM Getting Started with Palm® webOS Apps, PART 4: Working With Palm: Tools, programs, and app distribution. Ben and Dion with Stephen Feaster, Palm Developer Technical Support

Get ready for the webOS coding workshop Monday night by watching us demo the Palm Mojo SDK to build, debug, and run a simple app. Also, learn about Palm’s developer program and app distribution plans.

7:00-9:00 PM Coding Session: Up and Running with the Palm® Mojo™  SDK

Palm Developer Support Engineer Steven Feaster and other Palm resident webOS experts lead an informal workshop to help you get started with webOS app development. Palm’s staff will be there to provide individual and group hand-holding and instruction as you get up and running on webOS. Bring ideas for cool mobile apps and a wide open mind. And be sure to bring your laptop with Mojo SDK installed,please. To get the SDK, go to developer.palm.com and follow the signs to download. Food and cold beverage will be served!


12:15-1:30 PM Palm booth in the main exhibition hall

Come see Palm staff during lunch. Get your hands on Palm Pre and Palm Pixi, and say hello to Ben, Dion, and others from Palm engineering and developer relations.

6:30-9:00 PM Dinner reception and Palm booth

Same as above. See you there!


12:00-1:15 PM Palm booth in the main exhibition hall

We’ll be back at the booth during lunchtime.

1:15-1:45 Palm Keynote Address: The Future of Web and Mobile, Ben and Dion

Palm’s developer relations codirectors share their vision for the future of computing and the convergence of web and mobile technologies.

It’s not too late to register. Go to http://sprintadp09.com/sprint_ADP. html

Mitch Allen, Palm HI and engineering at Sprint Developer Conference

0 BY devrel

This just in: Palm Software CTO will be joining Ben and Dion Monday morning at the Sprint Developer Conference to deliver a technical overview of webOS. This is a great opportunity to get Mitch’s latest insight into webOS and writing webOS apps.

Later that morning, you can also hear from members of the Palm’s HI and engineering teams talk about webOS HI and app design. They’ll go way  under the covers of one of the shipping Palm apps to show you the ins and outs of how its functionality is written.

We’ll have complete details of what we’re up to on Monday at the conference — including more info about the coding session we’re hosting that evening (and yes, there will be food and cold beverage) — by tomorrow, so check back then.

If you’re going to be in Santa Clara for the Sprint Developer Conference, don’t miss it. If you haven’t registered yet, go to http://sprintadp09.com/sprint_ADP. html

What’s Happening in webOSland

0 BY devrel

What’s happening in webOSland is a collection of interesting links to articles and conversations about webOS and webOS development. If you have something you think we might want to include in future postings, you can send it to us at pdn@palm.com or via twitter to @webosdev

  • New from the folks who run Pre101.com: Wiki-based http://webOS101.com which is intended to be  an interactive resource for webOS programming. The plan is to  focus specifically on the tools and techniques for developing webOS apps and extend the documentation available in the SDK docs to help take the frustration out of developing webOS apps.

Join us in Santa Clara, CA, next week at the Sprint Developer Conference

3 BY devrel

If you’re already registered for the Sprint Developer Conference, look for us there. If you haven’t, there’s still time. Go to http://sprintadp09.com/sprint_ADP. html for more information.

This is the first time Sprint has opened the doors of its conference to all developers. In keeping with that spirit, Palm Developer Relations Directors Ben Galbraith and Dion Almaer will play host to a variety of activities to help open the kimono about webOS to the wider world of mobile developers.

Here’s what we’ll be doing, with Ben and Dion MC’ing:

  • 4 hours of mostly technical sessions introducing webOS to developers. They’ll be joined by resident experts from the Palm software engineering team to give you the low-down on Mojo and webOS. Special guests from the developer community will also join Ben and Dion to demo their apps and talk about how they got going on webOS.
  • A 2-hour coding session, where Palm developer technical support and engineering staff will help you get started with app development.
  • A keynote address by Ben and Dion, where they’ll share their vision for the web and mobile development

If you’re there, please come see us at the Palm booth at the exhibition.

Are your webOS applications Pixi ready?

0 BY devrel

We’re preparing Pixi to be available in time for the holidays. Are you preparing your applications for Pixi?

If you haven’t looked at Pixi, you can find details of the Pixi announcement here. We want to encourage all webOS developers to build your app to run on both Pixi and Pre, adapting as necessary to work properly and look good on both devices.

There are  only two significant differences between Pixi and Pre:

  • Pixi’s display resolution is different – it’s 320×400 pixels, as opposed to Pre’s 320×480
  • Pixi doesn’t have WiFi

Designing for different display resolutions

The display resolution difference will affect some applications more than others. If your application presents content and interface elements in a list-like or vertically stacked layout and makes use of Mojo widgets, you shouldn’t have to do much to support Pixi.  On the other hand, if your app is designed to fill the screen, you will need to approach your layout with flexibility in mind. To help you do this, Palm’s Human Interface team has prepared a document that you can find at http://developer.palm.com/images/palm/pdf/flexibility_responsiveness.pdf.

To test your app at the new device’s resolution, you’ll need to configure the Palm Emulator to run at 320×400. This page explains how.

Designing your app to work without WiFi

With rare exceptions, Pixi’s lack of WiFi should not affect your application. WebOS apps should be designed in such a way that they operate well in a WAN-only scenario, since even users with WiFi-capable devices are frequently not connected to a WiFi network. If you want to alter your app’s behavior based on the presence/absence of WiFi at any given time, you can use the Connection Manager API to check whether a WiFi connection is active.

Applications that fundamentally depend on WiFi such as desktop sync apps will need to be rearchitected to work without WiFi. If rearchitecting is not a viable option for a particular application, then that app may simply not be a good fit for Pixi at this time and we encourage the developers of those apps to recognize this and inform the user appropriately if they try to run the application on a Pixi device anyway. We also recommend that limitations are documented in the App Catalog description to prevent the disappointment of a user downloading an app they can’t use.

What’s happening in webOSland

0 BY devrel

What’s happening in webOSland is a collection of interesting links to articles and conversations about webOS and webOS development. If you have something you think we might want to include in future postings, you can send it to us at pdn@palm.com or via twitter to @webosdev

Immersive App Guidelines

2 BY devrel

Greetings, webOS developers!

On September 28th, 2009 we updated the Application UI Checklist, which you should use to cross-check your app’s UI before submitting it to the App Catalog. The checklist is mainly intended for standard applications, to ensure that they work, look and feel like other standard webOS applications. But there are other kinds of applications – apps that provide an “immersive, customized” user experience, like what we commonly see in games. Does the UI Checklist apply to those apps? We’ve been asked that a lot lately.

While reviewing “immersive applications” over the last few months, we’ve noticed that:

  • Immersive app developers commonly use custom controls (instead of standard webOS framework controls).
  • Immersive app UI designs (especially for games) are complex, and commonly contain tap targets that are smaller than what we recommend (minimum size = 48 pixels).
  • Immersive app developers commonly include buttons in their UI that navigate to different scenes in their app hierarchy, including buttons like “Back,” “Next” and “Home.”
  • Performing the back gesture feels “natural” when in Portrait orientation, but not in Landscape.

We’ve given this a lot of consideration and have the following advice for developers who are creating apps that provide immersive user experiences:

Use one style of controls consistently:

  • If your app uses custom controls in a scene, use those exclusively.
  • If your app uses framework UI controls in a scene, use those exclusively.
  • Do not mix custom controls and framework UI controls.

When displaying a standard scene in your app:

  • Include required UI elements like the App Menu and its standard items (Edit, Help) and the standard Help scene.
  • Support required behaviors users expect, like the Back Gesture.
  • Ensure that your app displays banner notifications and popup notifications from other apps, when they occur.

When displaying a scene in full screen mode:

  • Provide all the UI controls a user needs to navigate to different scenes in the app.
    • It’s okay to include Back or other scene navigation buttons in an immersive full screen UI.
      • If the fullscreen scene is in Portrait orientation, you must support the Back Gesture.
  • Provide visual tap feedback.
    • When a user taps a button, make sure it changes so the user knows the app received the tap.
  • Make sure tap targets are large enough to tap.
    • In standard apps, we recommend tap targets be no smaller than 48 pixels. Developers have told us they think this is “kind of big” for game UI’s, where every pixel is precious. If you must use smaller graphics, increase the size of the DIV they’re enclosed in whenever possible, to increase the size of the tap target. Don’t ever make the tap target smaller than 32 pixels, because targets smaller than that are difficult to detect reliably.
  • Design your UI to run on each webOS device
    • The Palm Pre is a 320 x 480 pixel device. The Palm Pixi is 320 x 400. Make sure your app runs on each. For tips regarding how you can optimize your design for each device, read the document Designing for Flexibility and Responsiveness.
  • Test your app on each webOS device
    • Test your app on the webOS device it’s intended to run on. This is especially important for developers porting apps from other mobile platforms. Try your apps and make sure everything in your UI still feels big enough to tap.

We’re providing these guidelines here for you now, and will add them to the App Checklist in time. For now, you can rely on these as our official recommendations when designing and implementing apps that use fullscreen mode to provide users with an “immersive user experience.”

The Palm UI Design Team

What You Need To Know About the Palm App Distribution Program

4 BY devrel

Following up on the release of the beta app catalog e-commerce program, we’re excited to announce that we’re opening our app distribution program to the entire Palm® webOS™ developer community by the end of the year.

This is an exciting moment for us as we share our vision and future plans. In response to your feedback on existing programs, and drawing on the web for inspiration, we designed our program to give you the kind of choice you’d expect from a web platform and to create both a better developer and user experience for mobile apps.

The Program’s Inspiration

The web as a platform isn’t just about how applications are developed, but how they are distributed and discovered as well.  The web, and the value of the community that drives it, were top-of-mind considerations as we brought the individual elements of the program together.

Specifically, we appreciate that the web is not only a large distribution channel, but also an incredibly smart and efficient one.  The community actively helps users find the content, people, and services that are relevant to them. It also brings more creativity to that process than we could ever assemble inside of Palm.  The community touches nearly every possible customer, and has demonstrated it can monitor its own user-generated content, services, and spaces.  At Palm, we want to create great mobile experiences for both the developer community and the web community at large.

Also, we appreciate that accessible, transparent online marketplaces are well accepted and have driven results for those who participate—both those who build and sell products and those who consume them. These promotional opportunities provide developers and merchants great opportunities to invest in their business—to drive awareness and get value for their marketing investment and do so with transparency and efficiency.  These new marketplace mechanisms are driving huge value for those who use them.

You’ll see in our initial program the start of our investment in the community and the use of market forces as natural mechanisms for applications to find their value and for developers to build their businesses around.  Let there be no question: We envision a Palm application ecosystem and product experience that is even more community and market driven—both on our devices and off.  The initial program elements you’ll read about here are twinkles in our eyes relative to where we can go and what we can do.  We look forward to building out this program and its possibilities with your involvement.

The Program Basics

Later this year, you’ll be able to choose from the following methods of distributing your applications as part of membership in the Palm developer program ($99 at developer.palm.com):

  • Promote your free or paid applications on the web for distribution to webOS devices.  Apps require self-certification according to Palm’s guidelines but are available to promote freely in any online channel with a unique URL without Palm application review. You can also provide access to other relevant content about your app, including descriptions and reviews.  Applications will be distributed to any webOS device using our over-the-air service.
  • Promote your applications in the on-device Palm App Catalog.  Distribute and promote your free or paid apps to webOS devices using a highly targeted channel, the on-device Palm App Catalog.  These apps will be reviewed and approved by Palm.  Recognizing the value of the on-device catalog as a distribution channel and as a friction point to control the flow of apps into it, we’re going to charge $50 for each app you submit to this channel.
  • Priority placement in the app catalog.  A limited number of priority placements will be available in the catalog if you want to obtain greater visibility for your application.  These placements will be openly available for bid in our auction system at prices that are determined by the community, based on demand.

All paid application purchases entitle the registered application developer to receive 70% of revenues, net of applicable taxes.  Developers who charge for their software will need to set up a PayPal account to receive their share of revenue from Palm.  Customers will initially be able to purchase applications with MasterCard and Visa.

Additionally, if you are an open source developer, you can promote your open source software on the web through a unique open source method without paying the $99 program fee.

More Details

Palm App Catalog. The Palm App Catalog represents the most targeted channel to webOS customers, as it is available on every webOS device.  Distribution through this branded, targeted channel requires application review.  Apps can be submitted through the developer site at developer.palm.com. They are subject to approval according to the Palm User Interface Guidelines as well as the Palm Application Content Criteria.  As announced in August, we are accepting applications to the beta app catalog e-commerce program for distribution on the catalog.

Recognizing the value of the on-device catalog as a distribution channel and as a friction point to control the flow of apps into it, we’re going to charge $50 for each app you submit to this channel.  This fee covers the lifetime of the app, even though Palm may review many versions of it.  Palm will review apps in the order in which they are received and will respond in a timely fashion. Should your app be rejected, Palm will let you know specifically why the app was rejected, and you can revise and resubmit your application.

We will also make priority placement opportunities available within the Palm App Catalog for developers to gain more visibility for their application. We have heard feedback that there are too few options for investing in the promotion of applications, and we want to provide developers the ability to invest and grow their business. These promotional opportunities will be open, transparent, and priced by the market through an auction mechanism.

Web distribution. Recognizing the value of the web community and the web as a promotional channel, Palm will invest in the tools and services that help you utilize the web and other online channels as powerful promotional opportunities for webOS applications.  This approach also addresses feedback we’ve heard from developers who are frustrated by a review-first, publish-later process.

To enjoy the full capabilities of our program, you can self-certify that your app meets the Palm User Interface Guidelines and Palm Application Content Criteria and receive a unique URL to start promoting the app online within hours.  You can use this URL in any of your existing online marketing assets, and you can begin selling these applications immediately, without review by Palm.  With this URL, you can create or use existing marketing channels such as your email list, blog, SEO, and more.  These links will provide the ability for users to authenticate and instantly receive applications directly to their devices using Palm’s over-the-air distribution mechanism.

Public feeds of these URLs and other relevant application data (such as reviews and ratings) will also be made available to the community to help applications find their market. We’re excited to see the emergence of directories, ranking mechanisms, and other inventive services that can be built around this data.

We expect this form of distribution to be especially popular while applications are still in their beta phase, when you are anxious to get applications to customers ASAP to create rapid feedback cycles and help improve the quality and usability of applications.

Open source apps.  The web would never have happened without the open source movement. In this tradition, we will enable the distribution of open source webOS apps to the web without you having to pay the $99 program fee. If the source of your app is available to the public under one of the commonly accepted licenses (BSD, Apache, GPL, MIT, etc.), you can distribute your apps on the web for free.  Open source projects will have a separate registration process and these open source accounts can only have open source projects associated with them. You will still have to register at webOSdev to download the Palm Mojo™ Software Development Kit; SDK downloads are free.

The Rules

Palm has built a set of application criteria intended to provide a great webOS experience.  We expect these guidelines to evolve and change as the developer and end-user communities become more active in our review and merchandising practices, and as our device and service capabilities evolve.

The Palm Application Content Criteria exist largely to ensure a high standard of application content, performance, and appearance as well as to protect webOS devices, other webOS apps (and particularly the data they rely on), and the carriers’ networks.  You will want to review these rules carefully, since they give Palm the right to suspend or discontinue distribution of your application if you choose to disregard them.

By opening up a web distribution channel free from our review, we are placing a great deal of trust in you—the developer—and the community.  We want you to embrace these principles, establish a high bar of quality and user experience, and help enforce these rules.  Our commitment to you is that we will be clear and transparent about these guidelines, and continually invest in our services that will give you more freedom over time with our platform.

What Now?

While the full program has yet to be released, you can download the Mojo SDK for free at webOSdev and join the webOSdev community to participate in our forums and both give and receive support on webOS application development.

Additionally, you can submit applications to be considered for our e-commerce beta program, which will run until our full program is released before the end of the year.

We look forward to building great mobile experiences with all of you, and as always, welcome your feedback.  Tell us what you think by sending a note.  And stay tuned for more details about the app distribution program as we get closer to launch!

Finally, we would like to take a moment to thank our early access partners and developers who have been working with us to build our platform and program.  Today these partners have introduced over 125 applications that have been downloaded almost 8 million times since the first webOS device, the Palm Pre™ phone, shipped just three months ago.  It has been great working with you, and we look forward to more!

—the Palm Developer Relations team