• We implemented support for application caches, which are a great replacement for Gears’ offline features. App caches are already being used by web apps like the NYTimes app in the Chrome Web Store. There is also full-featured debugging support for application caches in Chrome’s developer tools.


• Together with our friends at Mozilla and Microsoft, we proposed, specified, and implemented the IndexedDB API. This can take the place of the Gears Database API.


• We implemented the HTML5 File API, which is very similar to the Gears Blob functionality.


• We implemented the geolocation, notifications, and web worker APIs, which were pioneered by Gears, natively in Chrome.

With all this now available in HTML5, it’s finally time to say goodbye to Gears. There will be no new Gears releases, and newer browsers such as Firefox 4 and Internet Explorer 9 will not be supported. We will also be removing Gears from Chrome in Chrome 12.

The code itself will of course remain open source, and anyone is free to use it.

Our mission with Gears was to enable more powerful web applications. Over 5 releases, we added tons of APIs, enabling everything from offline access to parallel computation. Now that these features have all been adopted by browsers and have official W3C specs, they are available to more developers than we could have reached with Gears alone.

Edit: Corrected timeframe for removing Gears from Chrome.

Posted by Aaron Boodman, Gears Team

• onprogress() events for HTTP downloads and uploads
  
• Gears dialogs localized to 40 languages
  

• onprogress() events for HTTP downloads and uploads
  
• Gears dialogs localized to 40 languages
  

• Starting With Gears
• Offline Architectures
• Online/Offline Detection
• Gears Permissioning
• Installation and Detection
• Using LocalServer With Web Applications Spread Across Different Hosts
• Database Performance and Reliability
• Offline User Interfaces
• Maintainable Workers
• Choosing Names for Databases and LocalServers
• Storing Data on Users' Machines
• Desktop Shortcuts
• Versioning Database Schema
• LocalServer
• Syncing
• Giving Web Applications Similar Features to Desktop Applications

• Starting With Gears
• Offline Architectures
• Online/Offline Detection
• Gears Permissioning
• Installation and Detection
• Using LocalServer With Web Applications Spread Across Different Hosts
• Database Performance and Reliability
• Offline User Interfaces
• Maintainable Workers
• Choosing Names for Databases and LocalServers
• Storing Data on Users' Machines
• Desktop Shortcuts
• Versioning Database Schema
• LocalServer
• Syncing
• Giving Web Applications Similar Features to Desktop Applications

Would you like to add the same kind of fast, local searching to your own web page and web applications? This article introduces you to PubTools Search and the Gears features that power it, namely Full-Text Search and Workers. PubTools Search is an open source JavaScript library that drops a client-side search engine right into your page. You configure it with basic HTML plus a list of URLs to index. Once loaded, a search form that uses the local Gears full-text search abilities will appear in your page to quickly and locally search over the documents in real time as a user types into the search field.

The article covers the following:

• An introduction to Gears' Full-Text Search and Worker features
• How to drop PubTools Search into your page to quickly get going
• Deep walkthrough and dissection of how PubTools Search works internally with source code and snippets so you can use these Gears features in your own applications
• An introduction to parts of the Dojo toolkit used in PubTools Search, using actual source from PubTools Search including a discussion on some of the techniques used in modern JavaScript development
• Tips and tricks when working with Gears

Read the full article and try the demo yourself!

Would you like to add the same kind of fast, local searching to your own web page and web applications? This article introduces you to PubTools Search and the Gears features that power it, namely Full-Text Search and Workers. PubTools Search is an open source JavaScript library that drops a client-side search engine right into your page. You configure it with basic HTML plus a list of URLs to index. Once loaded, a search form that uses the local Gears full-text search abilities will appear in your page to quickly and locally search over the documents in real time as a user types into the search field.

The article covers the following:

• An introduction to Gears' Full-Text Search and Worker features
• How to drop PubTools Search into your page to quickly get going
• Deep walkthrough and dissection of how PubTools Search works internally with source code and snippets so you can use these Gears features in your own applications
• An introduction to parts of the Dojo toolkit used in PubTools Search, using actual source from PubTools Search including a discussion on some of the techniques used in modern JavaScript development
• Tips and tricks when working with Gears

Read the full article and try the demo yourself!

<JavaScript>
  // tells the swf if gears is installed
  function isGearsInstalled() {
    if (window.google && google.gears) { //gears is installed
      thisMovie("FlexGears").testForGears(true);    
      return;
    }
    //gears is not installed
    thisMovie("FlexGears").testForGears(false);    
  }

            
  function thisMovie(movieName) {
    if (navigator.appName.indexOf("Microsoft") != -1) {
      return window[movieName];
    } else {
      return document[movieName];
    }
  }
  // ....
</JavaScript>

<JavaScript>
  // tells the swf if gears is installed
  function isGearsInstalled() {
    if (window.google && google.gears) { //gears is installed
      thisMovie("FlexGears").testForGears(true);    
      return;
    }
    //gears is not installed
    thisMovie("FlexGears").testForGears(false);    
  }

            
  function thisMovie(movieName) {
    if (navigator.appName.indexOf("Microsoft") != -1) {
      return window[movieName];
    } else {
      return document[movieName];
    }
  }
  // ....
</JavaScript>

• Improving Browsers in New Ways: Gears++
• Google Gears for Mobile
• HTML 5, Brought to You by Gears
• Gears and MySpace - Search on the Client
• Taking Large-Scale Applications Offline
• Gears Case Studies

• Using GWT to Build a Diagramming Tool
• GWT and Client-Server Communication
• GWT Extreme by Ray Cromwell
• JavaScript and DOM Programming in GWT
• Resource Bundles and Linkers in GWT
• Deferred Binding with GWT

• Alex Russell on “Can We Get There from Here?”
• Spice up Your Apps with Google AJAX APIs
• Yours truly, Dion and Ben, State of Ajax: The Universe Is Expanding
• Steve Yegge on Server Side JavaScript

• Improving Browsers in New Ways: Gears++
• Google Gears for Mobile
• HTML 5, Brought to You by Gears
• Gears and MySpace - Search on the Client
• Taking Large-Scale Applications Offline
• Gears Case Studies

• Using GWT to Build a Diagramming Tool
• GWT and Client-Server Communication
• GWT Extreme by Ray Cromwell
• JavaScript and DOM Programming in GWT
• Resource Bundles and Linkers in GWT
• Deferred Binding with GWT

• Alex Russell on “Can We Get There from Here?”
• Spice up Your Apps with Google AJAX APIs
• Yours truly, Dion and Ben, State of Ajax: The Universe Is Expanding
• Steve Yegge on Server Side JavaScript

• Support for Firefox 3!
• Ability to create desktop shortcuts
• Improved support for customizing the installation flow and permission dialog
• Better support for sending complex objects to workers
• Detailed progress events for managed resource store updates
  
• And more...
  

• Support for Firefox 3!
• Ability to create desktop shortcuts
• Improved support for customizing the installation flow and permission dialog
• Better support for sending complex objects to workers
• Detailed progress events for managed resource store updates
  
• And more...
  

With the next release of the SDK, Appcelerator's javascript servicebroker will now automagically (and transparently) switch to using a Gears-enabled servicebroker when talking to your service-backend. That means your application will perform faster because the AJAX communication between client and server (especially for apps using fast polling) will be out-of-process using Gears' worker pool.

You have to do nothing to enable this in your application. When you Appcelerator application loads, a small piece of code will check to see if Gears is enabled and will dynamically load the gears-enabled servicebroker code.

With the next release of the SDK, Appcelerator's javascript servicebroker will now automagically (and transparently) switch to using a Gears-enabled servicebroker when talking to your service-backend. That means your application will perform faster because the AJAX communication between client and server (especially for apps using fast polling) will be out-of-process using Gears' worker pool.

You have to do nothing to enable this in your application. When you Appcelerator application loads, a small piece of code will check to see if Gears is enabled and will dynamically load the gears-enabled servicebroker code.

1. Improvements to Gears can be used by developers immediately. Gears is available today on Firefox (for Windows, OS X, and Linux), IE, and IE Mobile. Implementations for more browsers and platforms are in progress. Developers no longer have to wait for every browser to implement new web standards before they can use them, they only have to wait for them to be available on Gears.
   


2. Most browser vendors have two groups of customers: users and developers. User-facing features typically get more attention than developer-facing APIs, for a variety of reasons. But with Gears, developers are the only customers. We can focus completely on creating the best possible platform for web development.
   


3. Gears is an implementation of web standards that lives inside another browser. For example, the HTML5 Database API might be available to developers through both the google.gears object and the traditional window object. This is OK, and in some ways a good thing. Developers will be able to mix and match the pieces of Gears and native browser implementations that work best.

1. Improvements to Gears can be used by developers immediately. Gears is available today on Firefox (for Windows, OS X, and Linux), IE, and IE Mobile. Implementations for more browsers and platforms are in progress. Developers no longer have to wait for every browser to implement new web standards before they can use them, they only have to wait for them to be available on Gears.
   


2. Most browser vendors have two groups of customers: users and developers. User-facing features typically get more attention than developer-facing APIs, for a variety of reasons. But with Gears, developers are the only customers. We can focus completely on creating the best possible platform for web development.
   


3. Gears is an implementation of web standards that lives inside another browser. For example, the HTML5 Database API might be available to developers through both the google.gears object and the traditional window object. This is OK, and in some ways a good thing. Developers will be able to mix and match the pieces of Gears and native browser implementations that work best.

• PubTools: Brad developed this set of tools to enable offline caching of content in minutes. This is perfect if you have a set of content that you want to make available offline.


• Google Gears for Mobile: Just yesterday we launched our first Google mobile application using Gears, with Picasa


• Cross Domain Web Services: A good example using Flickr search


• Dojo Storage has just had a new release so it plays in the new Dojo 1.x land, and has a Gears storage engine


• blog.gears: Pamela Fox did a great job with this GData/Gears blogging application


• Gears + Greasemonkey = GearsMonkey

• PubTools: Brad developed this set of tools to enable offline caching of content in minutes. This is perfect if you have a set of content that you want to make available offline.


• Google Gears for Mobile: Just yesterday we launched our first Google mobile application using Gears, with Picasa


• Cross Domain Web Services: A good example using Flickr search


• Dojo Storage has just had a new release so it plays in the new Dojo 1.x land, and has a Gears storage engine


• blog.gears: Pamela Fox did a great job with this GData/Gears blogging application


• Gears + Greasemonkey = GearsMonkey

Class("HardWork", {
    meta: Joose.Gears,
    has: {
        data: {is: rw, init: {}}
    },
    methods: {
        onDoWork: function (result) {
            ok(result == 1001, "Gear Worker returns correct result")
        }
    },
    workers: {
        doWork: function (start) {
            var counter = start;
            for(var i = 0; i < 1000; i++) {
                counter++
            }
            return counter
        }
    }
})

var hw = new HardWork();

hw.doWork(1)

Class("HardWork", {
    meta: Joose.Gears,
    has: {
        data: {is: rw, init: {}}
    },
    methods: {
        onDoWork: function (result) {
            ok(result == 1001, "Gear Worker returns correct result")
        }
    },
    workers: {
        doWork: function (start) {
            var counter = start;
            for(var i = 0; i < 1000; i++) {
                counter++
            }
            return counter
        }
    }
})

var hw = new HardWork();

hw.doWork(1)

var timer = google.gears.factory.create('beta.timer');
timer.setInterval(function() {
  // get a new db handle on each iteration
  var db = google.gears.factory.create('beta.database');
  db.open('database-xssinterface');
 
  db.execute("BEGIN TRANSACTION");
 
  // find new messages for meps
  var rs = db.execute('select id, message from XSSMessageQueue where recipient_domain = ? and channel_id = ?', [recipient, channelId]);

  // there are new messages for the recipient
  while(rs.isValidRow()) {
          var id   = rs.field(0);
          var text = rs.field(1);
          wp.sendMessage(text, message.sender);
          db.execute("DELETE from XSSMessageQueue where id = ?", [id]); // unqueue message
          rs.next()
  }
 
  rs.close();
 
  db.execute("COMMIT")
 
  db.close();
}, 300);

• A way to run your Gears code on server, for example, if the user doesn't have Gears installed. In certain use cases, you could decide to run the code back on the server, and offer the user to "speed this all up by installing Gears"
• One API means that you can take tools and code that you have written on top, and have it automatically work on the server too. For example, we have already seen a GearsORM that works behind the scenes

• New modules: HttpRequest and Timer. The main reason for these modules was that developers told us they wanted to make HTTP requests and create timers inside Gears workers. But these modules can also be used outside of workers. For example, one advantage to using the Gears HttpRequest module instead of normal XMLHttpRequest is that Gears HttpRequest module addresses a common problem making comet-style applications work on IE.


• Improved support for handling errors in workers. This is an area where we received a lot of good feedback. Now, errors from workers are automatically bubbled up to the main page by default so that you can see them in the error console or in Firebug. Or, you can handle them explicitly with the new onerror event.


• Ability to load workers from a URL, even cross-domain URLs. We've long wanted the ability to load workers from a URL. We've also wanted to provide a way for different domains to communicate safely. This is useful in the case of mashups, or when an application spans multiple domains. The new createWorkerFromUrl API solves both these problems.

var netCheck = new NetworkDetection("ping.html");

netCheck.addEventListener("online", function(eAja){
 $("display").innerHTML = "";
 $("display").removeClassName("offline");
 this.connected = true;
});
netCheck.addEventListener("offline", function(eAja){
 $("display").innerHTML = "d\ni\ns\nc\no\nn\nn\ne\nc\nt\ne\nd";
 $("display").addClassName("offline");
 setHelp("You are disconnected from the Project Draw server.");
 this.connected = false;
});

opensocial.HappyHourContainer.prototype.toISO8601String = function (date) {
    var zeropad = function (num) { return ((num < 10) ? '0' : '') + num; }

    var str = "";
    str += date.getUTCFullYear();
    str += "-" + zeropad(date.getUTCMonth() + 1);
    str += "-" + zeropad(date.getUTCDate());
    str += "T" + zeropad(date.getUTCHours()) +
               ":" + zeropad(date.getUTCMinutes())+
               ":" + zeropad(date.getUTCSeconds());
    var ms =  date.getUTCMilliseconds();
    str += "."+(ms < 10 ? "00"+ms : (ms < 100 ? "0"+ms : ms));
    return str;
};

While synchronizing your financial accounts, you can save the
authentication information offline on your computer using Google Gears.
Next time you click on 'Synchronize', Buxfer will use the information
stored in Google Gears, and you won't need to type it again.

You will have the convenience of not needing to login into your
financial institution repeatedly, as well as the peace of mind that
your private information is secure and completely under your control!

Like Mint and the others, Buxfer has introduced a way to let you easily synchronize your financial accounts from Bank of America, American Express, Citibank credit cards, Chase credit cards, and more than 300 others with your personal finance information on its site. It uses Google Gears to download your financial account information — your username and password — to an offline Buxfer component that lives on your computer, that syncs with your online Buxfer account. It’s the company’s policy to never store this sensitive user information on its servers. It accesses the data stored on your Google Gears database on your computer, and authenticates you and your information with your financial institution. You can delete the data or make it unavailable to Buxfer whenever you want.

Mint has received some heat from those concerned about letting a web startup store their personal data on its servers. Wesabe, like Buxfer, offers a set of financial information upload tools, so you can store your data on your own computer, then sync it with that site — we’ve found Buxfer’s implementation of this offline component to be easier to use.

• The UI looks to the local DB for data
• When an event happens it gets queued
• When an event happens the UI tries to send it to the cloud
• Events have status flags to let the system know what is happening

• ability to automatically detect referenced resources such as images, scripts, and stylesheets (including nested @imported stylesheets)
• automatic detection of network state with corresponding UI/feature changes (for example, when going offline, some features such as the 'add feed' link are removed since they dont apply offline)
• auto syncing of events. this demo records the adding and removing of feeds and automatically plays them back when the network comes back online
• use of the generic storage capabilities to store the feed data for offline viewing
• graceful fallback if no offline support is available (google gears not installed or not allowed to run). try viewing the site in Safari to see the 'no offline support' version, or just deny Google Gears when prompted

Leveraging client-side services, web application developers will be able to push some functionality, especially repetitive tasks on small, rarely-changing datasets, onto the client. When functionality is pushed to the client, the client will generally see a substantial performance increase and unbeatable application responsiveness. This is because there will be a 1 server to 1 client ratio, as the client would be running its own server. Meanwhile, the usage of server resources for these repetitive tasks is reduced, potentially saving companies money on hardware or minimizing the effects of rapid success, known as "Growing Pains".

1. Ensuring resources are available offline
2. Decoupling the application from the network
3. Persisting data on the client
4. Re-creating application state from persisted data
5. Developing a synchronization strategy.

By now, you should be itching to add offline support to your web application (we hope!). If you should take anything away from this article, it's that taking your application offline isn't as hard or complex as it may first seem, and that Gears is a joy to work with (and it'll become even easier and more fun as the project matures and is used by more applications).

As for us at RTM, we couldn't be happier with Gears. The speed at which we were able to provide offline functionality (four days from reading the documentation to a launchable implementation) is a testament to the quality, ease of use, and production-readiness of Gears. Many thanks to the Google Gears engineers for their foresight and for making this an open source project to which members of the Internet community can contribute.

• Cross-origin API support
• WorkerPool improvements: Automatically report errors in workers, createWorkerFromUrl()
• New Gears modules:
  
  • HttpRequest
  • Timer
  • Both of these can be used in workers.

• The current implementation and interaction model in Zoho Writer Offline
• The architecture decisions around syncing, and read/write operations
• How they chose Google Gears
• How they are going to contribute to the project (They have some interesting functionality that may make sense to be in the core).

API Abstractions

• There has been a fair amount of playing with the Database component, and its APIs.
• gears-dblib allows you to work with objects/hashes, and wraps a few common patterns. Think selectAll(sql, function(row) {}).
• Gears ORM is more about Person.select(), and object-y. I am sure we will see a port of ActiveRecord and Hibernate shortly!
• GearShift ports ideas from ActiveRecord Migrations. We need to think about how to evolve the DB over time.
• Our own Aaron Boodman has done some experimentation with a convenience wrapper around the Worker Pool API.

Library Integration

• Ext JS Gears Integration
• SQL Admin for Google Gears
• Aflax and Gears
• Flex and Google Gears: Christophe Coenraets has published the SalesForce automation tool used in the Gears keynote
  
• Dojo Offline runs on Gears. Brad Neuberg talks about his excitement over Gears, and where he sees things going.

Example Applications

• Google Reader was our first example of using Gears to take an application offline.
• Remember The Milk quickly outdid us with a very nice offline implementation including seamless background synchronization and full support for almost all their features.
  
• RSS Bling is a quick port of the RSS reader to work offline.
• DB Schema Editor is a nice implementation of drag and drop schema editing for Gears.
  
• Google Reader Gears Search adds search to Google Reader using Greasemonkey and the Gears full text search functionality.
  

Presentations, etc

• Aaron Boodman kicks it off in Australia
• Gears, Madrid Style
• Gears: Dojo and GWT
• If you fancy it in the queens english

• Linus Upson, engineering director for the Gears project, interviewed by ZDNet
• Mike Tsao, tech lead on Gears, on Google Code