Developer Blog

Connect IQ 3.0.4 Now Available!

10/23/18 @ 07:46 AM

Connect IQ 3.0.4 is here! Along with numerous bug fixes and improvements we have added support for a new, more powerful suite of media player UI customization APIs for music apps.

Get the SDK to start building enhanced music apps today!

Connect IQ 3.0.1 Now Available!

08/16/18 @ 09:57 AM

Connect IQ 3 is here! This version adds a number of new features and improvements:

  • New MapView allows you to embed map views into your Connect IQ apps.*
  • The new audio content provider apps type lets you make apps that interface with the media player. You can now make music, podcast, or other audio content apps for Garmin wearables.**
  • New Menu2 and CustomMenu provide a much richer menu framework.
  • Trial app support
  • New cryptography APIs for hashing and encryption/decryption.
  • New automatic symbol checking (ASC) checks your code for mis-typed symbols at compile time, but keeps the dynamic functionality of Monkey C
  • New onAppInstall and onAppUpdate functionality allow you run code at install time, including requesting OAUTH credentials
  • Capture beat to beat intervals using the optical heart rate sensor
  • New HTTP tracking dialog helps you debug web requests in the simulator.
  • Improvements like byte arrays, the ability to cache bitmaps in object storage, improvements to the persisted content system, and more.

Everything is ready for you; get started today!

* MapView available on Fenix 5X, Fenix 5 Plus family, Edge 520 Plus, Edge 820 family, and the Edge 1030 family
** Available on music capable Connect IQ devices.


Creating Music Apps in Connect IQ 3

08/13/18 @ 11:36 AM

In 2018 Garmin has launched multiple music capable wearable products that allow users to leave their phone at home while they live their active lifestyle. Users can copy their music library directly to the device, or they can install a Connect IQ audio content provider app that acts as a bridge between the wearable and a Content Delivery Network (CDN).

Connect IQ 3 audio content providers enable third-party music services to deliver protected content. They can download content from a CDN via Wi-Fi directly to the watch, and act as a plug-in to the native media player. The content is encrypted before it reaches disk and decrypted during playback

This post explains all the roles an audio content provider fills as well as the basics of implementation.

Read More

Using Map Views in Connect IQ 3.0

08/13/18 @ 10:58 AM

Garmin built itself as a company by making location aware products, and has grown to make products that serve automotive, aviation, marine, fitness, and outdoor markets. A cornerstone to location awareness is digital cartography. Garmin products are often used outside of cell coverage, and our users depend on us to know where you are even when disconnected from the cloud. For over a decade Garmin has been digitizing the world and putting maps on devices of all shapes and sizes.

With the addition of MapView objects, Connect IQ now allows your apps to take advantage of the digital cartography included on Garmin devices. You can use MapView objects to provide location context to the user, provide a preview of a course or route, or let the user browse their surroundings.

Integrating Map Views

Let’s talk through a common use case on Garmin devices. Assume the use case where you have a cloud database of routes that the user can choose to download to the device. You want to give the user a preview of the route on the map and give a clear call to action to the user to download. You also want to allow the user to touch the map to browse the route.

Setting The Scene

The first thing you need to do is tell the map where on the Earth you want to focus the user’s attention. The method setMapVisibleArea allows you to set a bounding box of Location objects that define what part of the world should render on screen.

Overlaying Content

MapView objects allow for two kinds of overlays: markers and polylines. A MapMarker instance represents a single location on the map. You can use either the default Garmin pin, or you can provide your own BitmapResource object. If you use a custom marker, you need to set the pixel that will be drawn at the exact location (the hotspot). If you pass an array of MapMarker objects to the MapView instance, it will add all of them to the map. Calling setMapMarker will clear whatever markers are currently set.

A MapPolyline instance represents a series of coordinates, like a course. You can set the width and color of the polyline. You can set the polyline for a MapViewusing setPolyline. A MapView instance can only have one MapPolyline instance set at any given time.

Preview and Browse

Going back to our example, remember that we want to allow the user to have a preview of the route with a call to action, but let them browse the content if they want a closer look. The MapView class handles both use cases in a single View using the map mode.

In MAP_MODE_PREVIEW the map view centers on an area. You can add a layout above the map with buttons and selectables to provide context and actions. You can use setScreenVisibleArea to communicate to the MapView instance what portion of the map is not obscured by your user interface.

Switching the map mode to MAP_MODE_BROWSE changes the map view to a browse interface. The browse interface will be same browse interface used natively by the device.

Tying it Together

We want to show the user a preview of the course we want to download before they download it, but how can we show it before we download the full course? One way to bring a polyline to your app is with a Google Polyline Algorithm Format. This allows you to send a polyline to your Connect IQ app as a string that can be decoded back into a polyline. The function below will decode a polyline string into an array of Location objects. To conserve memory, it will begin skipping over coordinates as the polyline grows in size, essentially downscaling the line as it grows in length.

    // Constant used to downscale detail as
    // line grows in length to conserve memory

    // Returns the decoded polyline string
    // in an array of longitudes and latitudes
    function decodePolyline(polyline) {
        polyline = polyline.toCharArray();
        var len = polyline.size();
        var indexJump = Math.ceil(len / MAX_POLYLINE_OBJECT_COUNT);
        var poly = [];
        var index = 0;
        var lat = 0;
        var lng = 0;
        var skipIndex = 0;

        while (index < len) {

            var byte = 0;
            var shift = 0;
            var result = 0;

            do {
                byte = polyline[index].toNumber() - 63;
                result = result | ((byte & 31) << shift);
                shift += 5;
            } while (byte >= 32 && index < len);

            var dlat = ((result & 1) ? ~(result >> 1) : (result >> 1));

            shift = 0;
            result = 0;

            do {
                byte = polyline[index].toNumber() - 63;
                result = result | ((byte & 31) << shift);
                shift += 5;
            } while (byte >= 32 && index < len);

            var dlng = ((result & 1) ? ~(result >> 1) : (result >> 1));

            lat += dlat;
            lng += dlng;

            if (indexJump == 0 || skipIndex % indexJump == 0) {
                var p = new Position.Location({:latitude=>lat/1e5, :longitude=>lng/1e5, :format=>:degrees});

        return poly;

In our UI we want to allow the user to switch between our user interface with the call to action and allowing them to browse. Rather than pushing and popping the map view with different modes, we can use a single view and switch modes in the delegate.

class MapSampleMapDelegate extends Ui.BehaviorDelegate {

    var mView;

    function initialize(view) {
        mView = view;

    function onBack() {
        // if current mode is preview mode them pop the view
        if(mView.getMapMode() == Ui.MAP_MODE_PREVIEW) {
        } else {
            // if browse mode change the mode to preview
        return true;

    function onSelect() {
        // on enter button press chenage the map view to browse mode
        return true;

Now in a single view we can provide a UI with a call to action and preview of the course and allow the user to browse the content as well.


Hopefully you can see from this that the MapView class is a powerful addition to the Toybox. By combining Garmin digital cartography with your content, you can bring a whole new level of location awareness to your apps.

Connect IQ 2.4.8 Now Available!

07/05/18 @ 09:13 PM

Connect IQ 2.4.8 is here! We have added support for the Edge® Explore. This easy-to-use GPS cycling computer features a preloaded Garmin Cycle Map that shows you the routes cyclists like to ride. A variety of connected features lets you stay in touch with other riders as well as the folks back home.

From a Connect IQ perspective, the Edge Explore has the same screen resolution and fonts as the Edge 1000 but does not support power, shifting, or downloadable workouts. If you support the Edge 1000 and do not use those features, you can add support for the Edge Explore by simply adding support in the manifest editor.

Get the SDK and build your app for the Edge Explore today!

Connect IQ 2.4.7 Now Available!

06/19/18 @ 11:14 PM

Connect IQ 2.4.7 is here! We have added support for the fēnix® 5 Plus family, the most powerful Connect IQ wearables ever made. For athletes and outdoor adventurers, the fēnix 5 Plus Series watches are the high-performance way to beat yesterday and bring your maps and music along. These rugged, premium-crafted watches feature routable color mapping, wrist-based heart rate, storage for up to 500 songs and our Garmin Pay contactless payment solution.

This version also adds support for the vívoactive® 3 Music. From playing sports to playing your favorite songs, vívoactive 3 Music is the smartwatch for your active life. It features on-device music storage, so you can bring your tunes along for every workout. This sporty smartwatch has wrist-based heart rate² and more than 15 preloaded sports apps, so you can choose how you like to get fit. Built-in GPS lets you accurately record outdoor activities.

Get the SDK today!

Five Things from Connect IQ Summit

06/06/18 @ 11:42 AM

Not able to come to the Connect IQ Developer Summit? You missed an awesome event, but thankfully we have some material to catch you up:

  1. Read recaps of the summit from MySwimPro and DC Rainmaker, and watch this recap video from MySwimPro:

  2. Browse photos from the summit
  3. Watch Ray Maker’s State of the Industry keynote:

  4. See the winners of the Connect IQ Developer Awards
  5. Download the beta of Connect IQ 3 with Maps, Music, and More

Due to corruption during recording, we unfortunately do not have videos of the breakouts this year.

As you can see it was an incredible event, and we hope you can join us next year. Like Ray says, the BBQ in KC is really good. (We’re biased, and can understand if you have other opinions).

Something You’ve Been Waiting For: Trial Apps

05/30/18 @ 08:54 AM

Looking to monetize your content? You should create a trial app.

Trial apps are downloaded by the user in a locked form. When the user launches the locked version, they will be instructed by a device nag screen that the app is a locked version and given instructions on where to go to get the unlocked version. The app implementation can lock down functionality based on the value of the Application.isTrial. The nag screens and digital rights management (DRM) are enforced by the app store and the device, but the unlock experience is a web experience implemented by you. You can collect leads, check if they are a premium member, or monetize in your unlock experience. Once the user has completed the unlock experience, they will have access to the unlocked version from the app store.

You can to create trial versions of apps for the following devices:

  • Approach® S60
  • D2™ Charlie
  • Descent Mk 1
  • Edge 130
  • Edge 520
  • Edge 520 Plus
  • Edge 820
  • Edge 1000
  • Edge 1030
  • fēnix® 5 family
  • fēnix Chronos
  • Forerunner 645 family
  • Forerunner 735XT
  • Forerunner 935
  • vívoactive® HR
  • vívoactive® 3
  • Oregon 700 family
  • Rino® 700 family
  • If you want to enable trial functionality for your apps, do the following:

    1. Contact the Connect IQ Developer Program to get the integration documentation
    2. Submit your UX documents to your developer program contact for certification
    3. Upload a your app (with unlock experience) to the app store as a beta app
    4. Allow Garmin to test the unlock experience
    5. When approved, upload a new app to app store for approval

    We look forward to working with you!

    Changes to the Position Permission

    05/28/18 @ 10:37 PM

    UPDATE: Use the Connect IQ 2.4.6 SDK to add the position permission to Watch Faces and Data Fields.

    In the past developers have had access to the user’s position via the Toybox.Activity.Info.currentLocation without a permission. This API provides live position information to data fields operating within an activity, and can be used by Watch Faces to acquire a last known location. In an upcoming change to Connect IQ, we will be changing the behavior of this API and require the Position permission. This change will be made retroactively back to Connect IQ 1.x devices, so developers should add the Position permission to their apps (including for Connect IQ 1.x products) before June 30th. Failure to do so will cause your apps to stop working after this change is implemented.

    Sightsee with HERE Technologies and Monkey C

    03/26/18 @ 07:00 AM

    Have you been looking for ways to make your Connect IQ more location aware? Richard Süselbeck of HERE Technologies has written an extensive post on how to integrate the HERE API to create a points of interest app that combines the Places and Routing APIs . It is a great read with tips any Monkey C developer can take advantage of.

    HERE is a leader in location technology, and the HERE developer platform offers numerous tools including geocoding, points of interest, routing, and traffic. Richard will be talking more about his solution and the HERE platform at the Connect IQ Developer Summit in April.

    Check out Richard’s post and register today for the summit.

    What to Expect at the Connect IQ Developer Summit

    03/12/18 @ 04:44 PM

    Summit Logo
    The 2018 Connect IQ Developer Summit is coming up soon, and you won’t want to miss it! Here are some of the agenda items you can look forward to:

    • Keynotes by Garmin CEO Cliff Pemble as well as by leaders and managers who will tell you about the latest products and the newest features of Connect IQ
    • Guest talks by HERE, Nordic Semiconductor, and Ray Maker
    • Lightning talks bydevelopers
    • Evening social events with Garmin team leaders, other developers and industry experts
    • Workshops and breakouts covering wireless, health, music, sensors, and advanced Connect IQ topics
    • Complimentary registration in the Garmin Marathon (full, half or 10K distance) on April 21, 2018
    • A free Connect IQ compatible device is included with registration

    We look forward to meeting you at the event, but act fast; registration closes on March 16th so register today!


    Connect IQ 2.4.3 Now Available!

    02/21/18 @ 05:15 PM

    Connect IQ 2.4.3 is now available for download. This updates our supported devices tables and provides some bug fixes. Get the SDK today.

    A Gentle Reminder About the GDPR

    02/12/18 @ 08:03 AM

    In April of 2016, the EU Parliament passed the General Data Protection Regulation (GDPR), an act that was designed to harmonize data privacy laws across the European Union (EU). The GDPR provides requirements for the lawful processing of EU Personal Data, including requirements related to data privacy, consent, and digital services, and goes into effect on May 25th, 2018.  GDPR generally applies to the processing of EU Personal Data, and it may apply to you or your company even if you are not in the EU.  Data protection authorities may issue fines up to 4% of annual global turnover or €20 Million, whichever is greater, for non-compliance.  Garmin wants to share this information, including the reminders of developers’ obligations, with our developer community as a courtesy.  This isn’t legal advice - this is a developer blog after all - and we encourage you to consult with your legal counsel for guidance. 

    Connect IQ is a global platform, and, as stated in the Connect IQ license agreement, developers are responsible for their apps’ compliance with all applicable laws, including those related to data protection and privacy.  Specific responsibilities related to privacy can be found in Section 2 of the Connect IQ license agreement.  Developers should review the GDPR to determine what obligations they may have under the GDPR.  These obligations may include the following:

    • Asking for consent for collection of Personal Data
    • Providing access to information on what Personal Data concerning them is being processed, where, and for what purpose
    • Providing access to any Personal Data collected from them free of charge
    • Ability for a user to erase their identity, including the ability to halt third party processing of Personal Data

    If your solution collects Personal Data in any way, including using the Communications permission to collect or retain Personal Data (potentially in conjunction with Sensor, Sensor History, or Position permissions) or using any other mechanism, you are responsible for ensuring that your solution is in compliance with the GDPR on or before May 25, 2018.

    You may now resume your regularly scheduled programming.

    Pro Tip:  Tackling Connect IQ Versions, Screen Shapes and Memory Limitations

    02/05/18 @ 02:14 PM

    This guest post was written by Peter De Decker, a Connect IQ developer from Belgium. Peter is the author of several Connect IQ apps, he also wrote a set of Connect IQ tutorials and maintains the Garmin Connect IQ Fans Facebook fan page.

    Garmin devices come in different shape and sizes, have different memory constraints, and have different levels of Connect IQ compatibility.  To be able to maintain different Connect IQ devices you can use the has functionality to test whether a certain feature is present on the device, but applying this technique too much makes the code unmanageable. You could also set up a Connect IQ project per device and copy/paste your code across your projects, but this is very labor intensive to keep your code in sync and is prone to mistakes.

    Using one code base to handle all Garmin devices compatible with Connect IQ is easier than you think.  All you have to do is combine two core features of the Connect IQ framework: inheritance and jungles. Let’s see how these features help you to solve the issues that held us back.

    Screen Geometry

    One way to solve different size/shape issues is to use the layout system. This works perfect for watch faces as you have a lot of memory available there. In data fields, the memory budget is usually tight and as the layout system has a higher memory requirement, I got used to opting for using direct drawing on the dc object instead. I want to have the same benefits as the layout system though, as I might want a different layout on each device.

    So how do we do this?

    • Define a base class CommonLogicView where we handle all logic that we have to do on each device.
    • Define a class called DeviceView for each device that we want to support. This DeviceView inherits from the CommonLogicView and implements the layout specifics for each device by drawing to the dc
    • Define a jungle that picks up the right files for each device.

    Let’s say that you’re trying to build for the original vivoactive and the Forerunner 735XT. These two products have different screen geometry and support different versions of Connect IQ. The picture below shows how the project will look like after this has been set up:

    We create dedicated folders for each device family and configure the monkey.jungle in such a way that the right source files are picked up for each device:

    project.manifest = manifest.xml
    # fix autobuild to be a specific device
    # define the actual sourcePaths

    The CommonLogicView is the base view. Here we handle all code that we can use in all the device implementations. It’s a pretty easy class, the main entry point into this class is the onUpdate function:

    class CommonLogicView extends Ui.WatchFace {
        // this is called whenever the screen needs to be updated
        function onUpdate(dc) {
            // Common update of the screen: Clear the screen with the backgroundcolor.
            // We can also do common calculations here, in this case we'll just get the current time
        // clears the screen and stores the width & height in global variables
        function clearScreen(dc) {
        function determineClockTime() {

    The DeviceView is where we implement the specifics of the device, so for the Forerunner 735XT we could have something like this:

    class DeviceView extends CommonLogicView {  // inherits from CommonLogic
        function initialize() {
            CommonLogicView.initialize();  // important to call the initialize of your base class, even when you have nothing to add…
        function onUpdate(dc) {
            dc.setColor(Gfx.COLOR_WHITE, Gfx.COLOR_TRANSPARENT);
            dc.drawText(width / 2, height / 2, Gfx.FONT_NUMBER_THAI_HOT, timeString, Gfx.TEXT_JUSTIFY_CENTER | Gfx.TEXT_JUSTIFY_VCENTER);
            dc.setColor(Gfx.COLOR_BLUE, Gfx.COLOR_TRANSPARENT);
            dc.drawText(width / 2, 140, Gfx.FONT_SMALL, "I'm Peter's favourite!", Gfx.TEXT_JUSTIFY_CENTER);

    For the vivoactive we have a similar file, but then implementing the specifics of the vivoactive:

    class DeviceView extends CommonLogicView {
        function initialize() {
            CommonLogicView.initialize();  // important to call the initialize of your base class, even when you have nothing to add…
        function onUpdate(dc) {
            // call the parent function in order to execute the logic of the parent
            dc.setColor(Gfx.COLOR_WHITE, Gfx.COLOR_TRANSPARENT);
            dc.drawText(width / 2, height / 2, Gfx.FONT_NUMBER_THAI_HOT, timeString, Gfx.TEXT_JUSTIFY_CENTER | Gfx.TEXT_JUSTIFY_VCENTER);
            dc.setColor(Gfx.COLOR_PINK, Gfx.COLOR_TRANSPARENT);
            dc.drawText(width / 2, 110, Gfx.FONT_MEDIUM, "I'm a cool watch!", Gfx.TEXT_JUSTIFY_CENTER);

    When we run the code this results in the following in the simulator:

    Full source code


    Memory Constraints

    The Forerunner 235 and Forerunner 735XT are both semi-round, but they have different memory limitations. For instance, in data field mode, the FR235 allows for 16K of memory, while the FR735XT has 26K of available memory to play with. That means we can pack 10K more goodies in the 735XT data field!

    To do this we apply the same technique of combining inheritance and jungles:

    In my Peter’s (Race) Pacer app I’m taking this technique to the extreme and have 4 layers of inheritance defined: CommonLogic, LayoutLowMemoryCommonHighMemoryLogic, and LayoutHighMemory. All layers inherit from each other so that I don’t have to write a single letter of duplicate code. This allows me to support all combinations of Connect IQ 1.x and 2.x devices from a single code base, while getting the max out of the available memory for each device! 


    Connect IQ Version Compatibility

    We are treated with more and more features being added to the Connect IQ framework. Older devices can not be upgraded to Connect IQ 2 because they don’t have enough processing power and/or memory available. Luckily we can apply the same technique of combining inheritance and jungles to be able to use new Connect IQ 2 features in our projects while simultaneously also retaining support for users that have Connect IQ 1 devices.  Cool, eh?

    Let’s demonstrate this with a sample project. I’m going to extend the watch face with the ability to pull “to do” lists from a web-service via a background process, while at the same time we continue to support Connect IQ 1 devices. Of course the functionality on the Connect IQ devices will remain the same as before the changes as there is no alternative to background services in Connect IQ 1.x.

    We open our project from before and add the Connect IQ abstraction layer, this is the one I’ve defined for Connect IQ 1:

    class CiqView extends CommonLogicView {
        hidden var message; // I could add this variable to the CommonLogicView class, this is to show that you can define class instance variables at any level in the inheritance tree…
        function initialize() {
            message = "I'm a CIQ1 device!";

    A very similar class we add for the Connect IQ 2 devices, looks quite similar, only difference being that we’ll pick up the message from the application class:

    class CiqView extends CommonLogicView {
        hidden var message;  
        function initialize() {
        function onUpdate(dc) {
            message = App.getApp().backgroundMessage;

    In addition we change the DeviceView to show the message variable. In the jungle file we either pick the source-ciq1 folder or the source-ciq2 folder. Our jungle file looks like this:

    project.manifest = manifest.xml
    # fix autobuild to a specific device

    Notice that with little effort we also added support for the Forerunner 235.

    We’ve also duplicated the application layer level. The Connect IQ 1 version is pretty straightforward (you can have a peek at the source on github). The Connect IQ 2 version is slightly more complex as we’ll implement a background service to fetch from a webservice here (trimmed for readability):

    class PetersWatchfaceApp extends App.AppBase {
        var backgroundMessage = "What should I do?";
        function initialize() {
        function getInitialView() {
            // register for temporal events, we don't need to check whether this is supported, we know we have a Connect IQ 2 device here!
            Background.registerForTemporalEvent(new Time.Duration(5 * 60));                
            return [ new DeviceView() ];  
        function onBackgroundData(data) {
            // store the data from the background event in a class level variable
            backgroundMessage = data;
            // we received a new todo item, invoke a request to update the screen
        function getServiceDelegate(){
            return [new BackgroundServiceDelegate()];

    The service delegate is the main entry point for the background service, inside we’ll fetch a random to do item from the web-service.

    class BackgroundServiceDelegate extends System.ServiceDelegate {
        function initialize() {
        // this is called every time the periodic event is triggered by the system.
        function onTemporalEvent() {
                "" + (Math.rand() % 100 + 1),  // get a random number between 1 and 100
                { "Content-Type" => Comm.REQUEST_CONTENT_TYPE_URL_ENCODED },
        // receive the data from the web request
        function onReceive(responseCode, data) {
            if (responseCode == 200) {
                Background.exit(data["title"]); // get the title part of the todo list…
            } else {
                Background.exit("Error " + responseCode);

    Full source code

    Hope you’ll like this technique!
    Happy coding!


    Tell Us How You Connect IQ

    01/31/18 @ 02:19 PM

    Update - we are extending the deadline from February 28th to March 15th

    At the 2018 Connect IQ Developer Summit, we will be hosting an hour of lightning talks where you can present the cool tricks you use and the use cases you solve to the Connect IQ community. Presenters will have seven minutes per talk. Apply to give a lightning talk by providing your name, email, title, and abstract. You must be an registered attendee of the Summit to present. The deadline to apply is March 15th.

    Apply to present a lightning talk today!

    Connect IQ 2.4.2 Now Available!

    01/12/18 @ 03:54 PM

    Connect IQ 2.4.2 is here, with support for the Forerunner® 645 and Forerunner 645M. The Forerunner 645 is the most advanced running watch Garmin has made, featuring advanced running dynamics, Garmin Pay™, and an attractive slim form factor. The Forerunner 645M is our first wearable that lets you download music to the watch, and connects with Bluetooth® headphones (sold separately) for phone-free listening. Leave the phone at home!

    In addition to letting you listen to your own music, the Forerunner 645M introduces the fifth Connect IQ app type: the audio content provider. Audio content providers act as plug-ins to the media player, and are allowed to download content to the device over Wi-Fi, serve content to the media playback system, as well as present user interface controls on the wearable for configuration and control. This represents a giant leap for Connect IQ .

    Our music SDK is still under development, and is not included with Connect IQ 2.4.2. If you are interested in creating a Connect IQ media apps, please contact the Connect IQ developer program and let us know, or register for the Connect IQ Summit in April.

    Get the Connect IQ 2.4.2 SDK today!

    Connect IQ 2.4.1 Now Available!

    12/06/17 @ 04:50 PM

    It’s here! It’s here! Here is a quick summary of the new features:

    • Barrels - Our new mechanism for packaging, sharing, and importing code libraries
    • Jungles - Our new build tool to simplify build configuration across multiple products
    • FE-C - New AntPlus classes for reading FE-C on Connect IQ compatible Edge® products
    • Running Dynamics - New AntPlus classes for reading running dynamics information on Connect IQ compatible wearable products
    • More Objects - Dynamic memory handles allow more objects in your apps
    • More Storage - New mechanism allowing more persisted storage for your apps

    Many of these changes come from feedback we heard at the Connect IQ developer summit. These features give developers powerful new tools to make apps for the ever growing list of Connect IQ devices.

    Get the SDK today! While you are at it, check out some of the upcoming changes to the Connect IQ store.


    Big Changes in Store for the Connect IQ Store

    12/06/17 @ 09:00 AM

    Since its launch in 2015, the Connect IQ store has grown from ten apps to thousands, and has users around the world downloading content. We know that the store is an important place for featuring your brand, and we are excited to give you a preview of what will be coming next year.

    Improved Discoverability Native Mobile Experience Localized Hero Images

    The front page of the app store has been reworked to improve discoverability for your apps. New categories will highlight apps, and real estate at the top of the page will feature apps for every device.

    The app store is being upgraded from a web view to a native experience. Navigating the store will be smoother than before, and your content will look better than ever.

    The app store will let you have hero images for your apps. These hero images can be tailored for each locale, allowing you to get your message out in every language. If you choose not to create hero images, the app store will use a default treatment for your app icons.

    The app store will be accepting hero images with app descriptions in the near future. Along with these changes, we are publishing new guidelines for creating icons and hero images for your apps. These guidelines are to help you create great looking apps for the store. The store will be launching in Q1 of 2018, so now is the time to get your assets ready for launch.

    Pro Tip: Do More With Connect IQ 2.4

    11/01/17 @ 11:09 PM

    We have already discussed the big features in Connect IQ 2.4, but we didn’t stop there; there are some other enhancements we made under the hood. These tweaks address some long-standing Connect IQ design decisions that have been holding back developers since version 1.0.

    More Objects

    Because Connect IQ devices may not have a memory management unit, the Connect IQ heap is designed to be self contained within a contiguous region of memory, and uses memory handles to track of addresses in the heap. What’s a memory handle you ask? You mean you never had to use GlobalLock to lock your Win16 memory handle? No? Well never mind then; if you need me, I’ll be crying about my wasted youth.

    In previous versions Monkey C had a maximum of 512 memory handles. Any created object (except numbers, floats, booleans, and symbols) would count against both memory handles and heap space. This meant that on an Edge® 1000, which has 1 MB heap for Connect IQ apps, you could run out of memory handles well before you ran out heap memory. The 512 handle limit also meant we generally discouraged developers from using objects for pretty much anything.

    In Connect IQ 2.4 the virtual machine will dynamically allocate handles when you are running low. Now new is your friend! Make everything a linked list! Now you just have to worry about running out of actual memory and not bookkeeping memory!

    More Storage

    Before we begin, it might help to have a refresher on what kinds of content are persisted to the file system.

    • Properties are constant values defined at build time in the resource property block. They are useful for product specific constants that shouldn’t be defined in code.
    • Settings are values that are user-editable through Garmin Connect Mobile
    • Storage are values that the application wants to persist across execution. They are written to disk

    Since 1.0, application storage has been implemented as a dictionary, and this had a double cost to the developer. First, the dictionary lived at run time inside the developer heap, so storing any content would cost against your available heap. Second, the dictionary has a serialized size limit of 8 KB, and if the storage crossed over that limit it would not be written to disk. Double-whammy!

    In Connect IQ 2.4 we introduce the Application.Properties and Application.Storage modules. Application.Properties provides an interface for accessing the values of properties and settings. Storage provides a new interface for persisting keys and values. Values persisted using Storage use a new on-disk database. Keys and values in the database are limited to 8 KB, and storing a value no longer costs against your heap usage! Even better, you now have 128 KB of storage - more memory than I could have imagined in my childhood!

    API Level Properties Settings Storage
    CIQ 1.x (Aikido Monkey) AppBase.getProperty
    CIQ 2.4 (Biker Monkey) Application.Properties.getValue
    AppBase.getProperty (uses 1.x storage)
    AppBase.setProperty(uses 1.x storage)

    If you are developing on a 2.4 compatible device, Storage offers a superior solution for persisting application data. It is important to note that this API will only be on Connect IQ 2.4 devices and above. If you’re trying to maximize the number of supported devices, use a Toybox.Application has :Storage check to see if the Storage API is available. Data stored using Storage will not be auto-migrated from data stored using AppBase to retain backwards compatibility.

    You’re now free to create more objects and store more data!

    Connect IQ 2.3.5 Now Available!

    11/01/17 @ 10:53 AM

    Connect IQ 2.3.5 is here! This SDK adds support for the upcoming Descent™ Mk 1 dive watch. The Descent is the first watch-sized dive computer to offer surface GPS navigation with full-color onscreen mapping and location reference. Note that for user safety, Connect IQ functions are not available while diving, so we can ensure that all dive capabilities are functioning as they were designed.

    Get the SDK to make your app available for the Descent!

    Connect IQ 2.4.0 Beta Now Available!

    10/18/17 @ 08:26 AM

    Barrels, Jungles, and ANT, oh my!

    Connect IQ 2.4 beta is here! Connect IQ adds new features to the Connect IQ SDK and some new device features.



    One of the most requested features from our developer summit was the ability to package code so it can be shared between projects, a la Ruby Gems or Python Packages. Monkey Barrels are the new Monkey C packages. They allow code and resources to be packaged into a shareable bundle that can easily be imported into other projects. Now you can put your shared libraries into their own projects, and make them easily available for others to use. We have added sample barrels to our github account for you to see how they work.


    Jungle Boogie

    Jungles are a domain specific language for managing build configuration through lazy evaluation of properties; easier put, it is Monkey Make. Unlike make tools that managing build dependencies, Jungles provide a tool for managing build configurations of multiple Garmin devices.

    Here is a simple, but relevant, example. Remember that time when Garmin turned the
    fēnix® Chronos into the fēnix 5s
    ? Now there were two round 218x218 products unlike the others. If you wanted to support all round 218 x 218 products you needed to create and manage three resource directories; two of them are duplicates.


    With Jungles, you can rectify the situation with one line.

    fenixchronos.resourcePath = $(fenix5s.resourcePath)

    Now building for the fēnix Chronos will use the fēnix 5s resources. You can use resources-round-218x218 for fēnix 3, and resources-fenix5s for fēnix 5s and fēnix chronos.

    One more example - lets say you are writing a wearable app that has different code for round versus semi-round versus rectangle layouts. Before you had to use build resources to specify the build paths, but with Jungles you can configure it in one place.

    # Configure paths based on screen shape
    round.sourcePath = $(base.sourcePath);source-round
    semi-round.sourcePath = $(base.sourcePath);source-semi-round
    rectangle.sourcePath = $(base.sourcePath);source-rectangle

    Now round products will automatically add the source-round path, semi-round the source-semi-round, and rectangle the source-rectangle. Jungles can control source path, resource paths, excludes, annotations, and barrels. Barrels include Jungles inside for their own build configuration, allowing them to have separate build configuration from the parent project. Jungles make it much easier to manage project build configuration in one place.

    Running Dynamics and FE-C

    Connect IQ 2.4 adds access to the Running Dynamics ANT+ profile for the Forerunner® 735xt, Forerunner 935, quatix® 5, and fēnix 5 family; and the FE-C profile to the Edge® 520, 820, 1000, and 1030.

    Getting Started

    We encourage developers to install a new copy of Eclipse Oxygen for Java Developers before installing the beta SDK to separate beta and production Connect IQ development environments.

    To install the new beta SDK, follow these instructions:

    1. In Eclipse, click the Help menu
    2. Choose Install New Software…
    3. Click the Add… button
    4. Add to the Location field and click OK
    5. Check the box next to Connect IQ in the Available Software window and click Next
    6. Review the license agreement and click Finish
    7. Once the installation completes, restart Eclipse
    8. After Eclipse re-launches, click the Connect IQ menu
    9. Choose Open SDK Manager
    10. Click the Download button next to the 2.4.0 Beta 1 SDK release
    11. Review the license agreement, and click Agree
    12. Once the download completes, click Yes when prompted to use the new SDK version as your active SDK
    13. Close the SDK Manager

    We also have beta firmware releases that support the Connect IQ 2.4.0 beta SDK available for the following devices:

    We are excited to see what you think! We’ll be updating the blog with firmware betas for Connect IQ 2.4; check back to see if we’ve added support for your device.

    Connect IQ Pro Tip: Connect IQ and Travis CI

    08/31/17 @ 09:19 AM

    This is a guest post written by Achim Seufert.

    You probably have already seen them all over GitHub; these fancy little badges indicating among other things that a project’s build-process is passingor failing. Check Bootstrap‘s main-page for example:

    They’re pretty much becoming a standard for projects using build-tools like Maven, Gradle, npm, etc. The badges actually aren’t a feature of GitHub itself, but originate from services like TravisCI, AppVeyor, or David. The README files of GitHub projects, usually plain Markdown-files being rendered to HTML, simply point to automatically generated images provided by these services.

    In this tutorial I’ll show you how to use TravisCI to build and track status of your Connect IQ project.

    Getting Started

    TravisCI is a free-of-charge continuous-integration-service for open-source projects that seamlessly integrates with your GitHub repository. Whenever you push some changes to your repository, TravisCI will fire up a fresh VM which can run a set of tasks which usually include compiling your code, executing unit-tests, packaging, and so on. Furthermore there’s a wide variety of options that let you define notifications being sent from TravisCI in case one of these tasks will fail or behave in an unexpected way. Our goal should be to have TravisCI build and package a Connect IQ-app and visualize the outcome of these tasks with either passing or failing.

    Building via the Command Line

    At this point I’m assuming that you already have created a GitHub repository containing your Connect IQ project. The most important task is getting our app built and packaged via command line instead of using the Eclipse Plugin. This can be achieved by invoking the Monkey C compiler through the monkeybrains.jar library which can be found in the bin-folder of your Connect IQ SDK. We also have to keep in mind that this should run on a UNIX-based console, since TravisCI starts a Linux-VM for us. As a side note it’s good to know that TravisCI is stateless, meaning you don’t have to worry about cleaning up your environment after a build; you’ll get a fresh VM every time a build gets triggered.

    Our compile/package command should look something like this:

    java -jar "${MB_HOME}/bin/monkeybrains.jar" ${PARAMS} ${SOURCES}

    We basically just use Java and execute the JAR’s main-class, passing in some params and sources. In order to make things a bit more generic and convenient, I’ve created a shell-script ( which wraps the calls to the monkeybrains.jar. Place it in your project root alongside the manifest.xml. The params are built automatically; source and resources will also automatically be found and passed over. Finally, the script can also be used to package the app. Compiling and packaging an app requires a “Developer Key” (see the Getting Started in the Programmer’s Guide).

    The three things the script needs in order to run are:

    1. The MB_HOME environment variable to be set and pointing to your Connect IQ SDK
    2. The MB_PRIVATE_KEY environment variable to be set and pointing to your private key
    3. A file called mb_runner.cfg, also residing in your project-root, which contains a few details specific to your app. Check out the mb_runner.cfg.sample and adjust the settings to fit your needs.

    If you want to see more details about mb_runner read the Running the following will build and package your app:

    ./ package

    Prepare the Project/Repository for TravisCI

    There are three more things to do:

    1. Create the .travis.yml config file in your repository-root
    2. In your repository root you’ll need to create a simple shell-script in which we’ll be preparing/invoking the mb_runner script
    3. Link your repo with TravisCI

    The .travis.yml file should look like this:

    language: java
    jdk: oraclejdk8
        - sudo apt-get install -qq dos2unix
        - ./

    Here we simply tell TravisCI to use a default Java environment (with Oracle’s JDK8 installed), install the required dos2unix package, and run the shell script shown below. This will prepare our freshly created VM-environment so we can run our actual MonkeyC-compile-job:

    # script to
    wget -O "${SDK_FILE}" "${SDK_URL}"
    unzip "${SDK_FILE}" "bin/*" -d "${SDK_DIR}"
    openssl genrsa -out "${PEM_FILE}" 4096
    openssl pkcs8 -topk8 -inform PEM -outform DER -in "${PEM_FILE}" -out "${DER_FILE}" -nocrypt
    export MB_HOME="${SDK_DIR}"
    export MB_PRIVATE_KEY="${DER_FILE}"
    ./ package

    As you can see, we’re downloading/extracting the Connect IQ SDK, generating a new private key for compilation/packaging, and setting the environment variables accordingly before running the mb_runner script.

    After committing/pushing the three new files (, mb_runner.cfg, .travis.yml) to your repo you can finally link it to TravisCI as a final step. Just head over to the TravisCI homepage and log in using your GitHub credentials. Navigate to your account-settings and simply select the repository you want to activate.

    And that’s it!  From now on every new commit/push to your repository will trigger TravisCI and compile/package your app. If any build errors occur when committing a change you’ll get notified about it.

    Adding Badges to the README

    As a reward for our hard work we now can decorate our repository’s main page by adding the status-banner. Replace `[username]`, `[reponame]`, `[branchname]` with values that fit to your project:

    ![Build Status]([username]/[reponame].svg?branch=[branchname])]([username]/[reponame])

    Of course you can put up an extra banner for each branch (master, development, etc.) you have.

    Including a Companion App

    If you happen to have an Android or iOS companion app along with your Connect IQ app, you could easily combine the build-process of both apps. If you’re having an Android app for example, then you’ll want to have it built by TravisCI as well. Since you’re already booting up a fresh Java-environment for this, you can just run your Connect IQ app build immediately afterwards. TravisCI will then return a combined result of both jobs meaning, if one fails then it will be an overall failure.

    For such a case, the .travis.yml file could look something like this:

    language: android
    jdk: oraclejdk8
        - tools
        - platform-tools
        - tools
        - build-tools-25.0.2
        - android-25
        - android-sdk-license-.+
        - '.+'
        - mkdir "$ANDROID_HOME/licenses" || true
        - echo -e "\n8933bad161af4178b1185d1a37fbf41ea5269c55" > "$ANDROID_HOME/licenses/android-sdk-license"
        - echo -e "\n84831b9409646a918e30573bab4c9c91346d8abd" > "$ANDROID_HOME/licenses/android-sdk-preview-license"
    # the following part will be used to perform a compile-/package-run for the ConnectIQ-app;
    # afterwards we change into the "android"-subfolder and continue with the standard Android Gradle-build
        - sudo apt-get install -qq dos2unix
        - cd ciq && ./
    - cd ../android && ./gradlew build

    mb_runner Submodule

    Instead of manually adding the mb_runner script to you project root, you also can include it as a Git submodule by running the following in your project root:

    git submodule add

    This will create a mb_runner subdirectory, containing the file. You will still have to add/create a mb_runner.cfg file in your project’s root and adjust it to your needs.


    Continuous integration has become a necessity of modern software project. Having TravisCI watch over your sources - ensuring that everything is still in a “buildable” state - makes commiting/pushing your code to the repo less frightening. Using the above techniques you can bring continuous integration to your Connect IQ GitHub projects.

    Achim Seufert is a developer in Würzburg, Germany. Check out his GitHub and website.

    Adapting Your App to the vívoactive® 3

    08/30/17 @ 07:48 AM

    While the vívoactive 3 is a complete revamp from the vívoactive HR, it is still a Connect IQ device through and through. Here are some tips and tricks for adding vívoactive 3 support to your Connect IQ app.

    Round is the New Black

    If you are seeing a pattern with the fēnix® family of products, the Forerunner® 935, the Approach® S60, and now the vívoactive 3, it is not coincidence: Garmin likes round watches. We like them because they look like watches instead of “wearable technology”. Yes, a rectangular display can hold more information, and yes, our devices capture and display much more information than a traditional wrist watch, but if it does not look good on the user’s wrist none of that matters.

    Watch Faces

    Watch faces work the same on the vívoactive 3 as they do on the fēnix 5 and the Forerunner 935. The vívoactive 3 supports always active watch faces as well, meaning your custom watch faces can stay always on and update every second while still having industry leading battery life.

    Data Fields

    When using three or more data fields on the vívoactive 3, the top and bottom fields are much smaller and designed for metrics that can be represented in simple terms, and the vívoactive 3 will not allow users to place Connect IQ data fields into the top/bottom areas. Otherwise, your data field should run just fine on the vívoactive 3.

    Device Behaviors

    The vívoactive 3 is our first one button watch. The button is used for start/stop, and there is no physical “back” button. The BehaviorDelegate will map a number of screen actions to behaviors:

    • Right swipe is now Back
    • Hold on the screen is now Menu
    • Swipe up and down is now Previous and Next page

    If your app currently overrides the above actions (right swipe, hold, or swiping up and down), they will interfere with the native actions of the vívoactive 3. If you are using the BehaviorDelegate to capture menu and back behaviors, your app will work without modification on the vívoactive 3.

    Use Selectables, Menus, and the Picker

    Make sure to take advantage of Menus and the Picker. These will always adapt to the native look and feel to the device and take advantage of input changes.

    The vívoactive 3 has a capacitive touch screen that you can take advantage of. The Selectables and Buttons framework, introduced in Connect IQ 2, makes it easy to design an interface that can be used by both touch and button products. At the Connect IQ Summit we gave a presentation about how to use Selectables and Buttons when designing your user interface.


    Connect IQ 2.3.3 Now Available!

    08/27/17 @ 05:28 AM

    Connect IQ 2.3.3 is here! This releases adds support for the exciting new products Garmin introduced this week:  the vívoactive® 3 and the Edge® 1030. Get excited - these devices are hot.

    The vívoactive 3, which we eluded to in a previous post, re-invents the vívoactive family. All of the features you love from the vívoactive - long battery life, Garmin Elevate™ wrist heart rate, Connect IQ - are now in a beautiful round body that looks appealing on men and women. Your apps will look stunning on its round 240 x 240 pixel touch screen. The user interface has been revamped to be more touch-centric; in fact, the device now only has one button. While a lot has changed, it is still very much a Connect IQ compatible product. Look for an upcoming developer post about how to adapt your app for the vívoactive 3.

    The Edge 1030 is the most powerful Edge yet. It features a 3.5” capacitive touch display, GPS/GLONAS positioning, altimeter, and supports ANT+ and BLE sensors. The product also steps up the navigation capabilities, including the introduction of on-device popularity routing. This is the top of the line device for your cycling apps.

    You know you want your apps on these devices. Get the SDK today!

    We Wish We Could Tell You This Amazing Reason to Port Your App to the Approach® S60

    08/04/17 @ 10:24 AM

    The Approach® S60 is a beautiful golf watch, complete with 40,000 pre-loaded golf courses, AutoShot game tracking, and touch screen display. The device is a great addition to the Connect IQ device lineup, and is worthy of porting your app to. There’s another great reason you should consider porting your app to the Approach S60, but we just can’t tell you.


    Look; this is killing us. Maybe we can hint at it: remember “square watch” and “round watch” from the preview SDK’s, and how they turned into the vívoactive® and the fēnix® 3? Maybe it’s like that, maybe it isn’t; like we said we can’t tell you. Or how about this: eviceday ompatibilitycay.

    Ugh, this is frustrating.

    In summary, if you haven’t ported your app to the Approach S60, you should think about it; first because it’s a great Connect IQ wearable, and second because…. nope, we can’t say. But we want to.

    Guest Post: Creating a Connect IQ Background Service

    07/24/17 @ 04:01 PM

    Simple Darksky! Waiting for approval right now, but here it is on the #fenix5

    A post shared by Jim M (@jim.m.58) on

    This guest post was written by Jim Miller, a Connect IQ developer in Phoenix, AZ.

    One of the new features in Connect IQ 2.3.x is background services, or the ability for a Connect IQ application to have a service that runs even if the main application isn’t running. Background services have different abilities than the main process; a watch face or data field that can’t do communications itself, but the background process can! The most common example of this right now is a watch face that displays weather information from the internet. When something happens in the background, that process can optionally prompt the user if they want to start the main application, or the background can just collect data for the next time the main application runs.

    I’ll be talking about background services that take advantage of temporal events. In simple terms, it’s a process that’s time driven: it runs every “x” minutes, or can be set to run at a certain time. Temporal events can fire at most every 5 minutes, and will run at most 30 seconds each time it runs. The focus here will be on background processes that don’t try to start the main app when something happens, but just collect data for the main process.

    I’ve created a very basic watch face with a background service on the developer forum and included a .zip of the project in the first post so you can see the code and try it out yourself. The watch face itself displays the time, and the last data seen from the background service (plus a counter, etc). And all the background does is return a string with an “hh:mm” timestamp. While it isn’t useful, it does show the basics of backgrounding with a temporal event. In this case, there’s really isn’t much in the View class, but the things to look at are in App class and the file with the background process - the ServiceDelegate.

    When doing an app with backgrounding, there are a few things that come into play. In the sample project, you’ll see how these pieces all fit together.

    The Background Annotation

    To save memory, each time the background service runs only the necessary code is loaded. Background services have a 32 KB heap, so things can get tight! The (:background) annotation is used to indicate what classes, modules, and variables need to be available when the background service runs. The main App class is loaded by default, but you want to use the annotation on things like the ServiceDelegate and any things it may use or reference.

    class BgbgServiceDelegate extends Toybox.System.ServiceDelegate {

    Using it doesn’t mean that it’s only in the background service; classes, modules, and variables will be available in both the main process and background process.

    Service Delegate

    A background service can be triggered by different kinds of system events: step goal achievement, sleep/wake times, and temporal events, which are discussed below. The ServiceDelegate allows you to define what your app should execute when these events occur. The AppBase.getServiceDelegate() is how the service delegate in your code is found. Use the methods in the Toybox.Background module to register your service to fire on given triggers.

    Temporal Events

    Background.registerForTemporalEvents() is used to set how often the background temporal event runs. In the sample code, I do it as part of AppBase.getInitialView() after doing a check to make sure the app is running on a device that supports backgrounding.

            //register for temporal events if they are supported
        	if(Toybox.System has :ServiceDelegate) {
        		Background.registerForTemporalEvent(new Time.Duration(5 * 60));
        	} else {
        		Sys.println("****background not available on this device****");

    Background.deleteTemporalEvent() can turn off the background process if desired. With a combination of those calls, you can get a bit of control over when a temporal event runs. For example, you can do things like not starting the temporal event until there is a connection to a phone, deleting the temporal event when your app no longer needs it, etc. Note: Normally when you have started a temporal event process, it will run even when the parent app isn’t running. With watch faces only the temporal event for the currently selected watch face will run.

    With some temporal events, you may want to pass an error status back to the main process instead of data. A good example of this would be a background service that does communications. In many cases, you will be passing back the data you received (I often just pass back the dictionary from the callback), but in the case of an error, I just pass back a Number representing the error. Then in AppBase.onBackgroundData(), I use instanceof Number to check if I got data or an error, and handle the error or data as needed. Here’s a simple example of that:

    function onBackgroundData(data) {
        if(data instanceof Number) {
            //indicates there was an error, and “data” is the error code
        } else {
            //got good “data”

    Interprocess Communication

    You pass data from your background service to the main process using Background.exit() in your ServiceDelegate

        function onTemporalEvent() {
        	var now=Sys.getClockTime();
        	var ts=now.hour+":"+now.min.format("d");
            Sys.println("bg exit: "+ts);
            //just return the timestamp

    AppBase.onBackgroundData() is how the main process gets the latest data from what the service returned by Background.exit(). In the main process, when it first starts, I’ll see if data is in the object store, and if so, then you display that as a “last known value”. If you don’t do something like this with a watch face, each time you leave the watch face and come back, there wouldn’t be any data until the background runs again.

        function onBackgroundData(data) {
        	var now=Sys.getClockTime();
        	var ts=now.hour+":"+now.min.format("d");
            Sys.println("onBackgroundData="+data+" "+counter+" at "+ts);

    You can’t use AppBase.setProperty() in the background process to pass data in the object store or settings; if you try, an exception is thrown. You also can’t pass information between the main process and the background with global variables. The word “process” is important here: global variables are per process, so the same global is only global for that process. A variable defined globally exists in both the main process and background process, but each maintains its own copy and they’re never synced.. That been said, the only way to pass data from the main app to the background service is as a property. Your ServiceDelegate can retrieve it with AppBase.getProperty(). It can be something in the object store or from settings. Make sure to handle the case where the background may not have the data it needs here, as there are things that may not yet have valid values.

    The background can run more than once before the main process sees it in AppBase.onBackgroundData(). The main process only sees the last one, not all of them, but in the background process you can use Background.getBackgroundData() to get what’s currently queued for the main process, but not yet delivered. You can combine that with what the background process has that’s new, and return it all.

    Other Points

    • Watch Faces - Watch faces are a bit different than other app times when it comes to if/when a background service runs, and this is by design. The background service for a watch face will only be run if that watch face is the “active” watch face (the one currently selected to be used). Think of the case where you have two watch faces installed, that both get weather data from the same source, with a limit on requests per day. There’s no reason for the background service for the non-active watch face to run, as it would just use up the quota of requests per day.
    • Size of response to makeWebRequest() calls - If you are doing Communications.makeWebRequest() calls in your background process, one thing to keep in mind is the size of the response you get back. The background process has limited memory. When a response is received, there must be enough memory to contain both the response and to build the dictionary passed back to your callback.
    • Notes about the Simulator: - You can test backgrounding in the simulator. In the case of temporal events, they will occur as scheduled, but under the “Simulation” menu, you can trigger the background process to run.

      There is a known issue with the simulator with background apps: the simulator will run the background services of apps you’ve tested in it, even if it isn’t the “active” app being tested. So if you are testing “app a” and then switch to “app b”, the background for “app a” will run as well as the background for “app b”. Even if your current target doesn’t have a background service the simulator may attempt to start it. The Connect IQ team is aware of the issue and will address it in a upcoming release

    As you can see, background services are a powerful new addition to the Connect IQ toy box. They allow your app to periodically poll the internet for information, including watch faces and data fields. What can you use them for?

    About The Author Jim Miller is a Connect IQ developer in Arizona. “In early 2015, I had a forerunner 15, and liked the GPS and step tracking. Then the original vívoactive was announced, and I pre-ordered it, and downloaded the CIQ 1.0.0 SDK the same week!” You can see his apps on the app store and find him on Instagram, his Connect IQ Facebook Page, or on the Connect IQ forums.


    Connect IQ 2.3.2 Now Available!

    07/24/17 @ 02:55 PM

    Connect IQ 2.3.2 is here! This version adds support for the D2™ Charlie aviation watch. With a rich array of color mapping, weather, waypoint reference and flight logging features, D2 Charlie sets the standard for on-wrist situational reference and backup navigation in your cockpit. The device is CIQ compatible with the fēnix® 5X, so make sure to support both devices.

    Get the SDK today!

    “This App Is For Testing Purposes Only”

    07/10/17 @ 06:12 PM

    The Connect IQ app store is introducing a new feature today: beta apps. This feature allows developers to test app settings and Garmin Connect integration in production without releasing the app.

    Uploading a beta app will let you stage your app in production. To use this feature, you will need to create an alternate app id in your manifest using a UUID creator. Beta apps will show up in your uploaded apps, and you can download them to your Garmin device. Once downloaded you can edit app settings in Garmin Connect Mobile and Garmin Express, and test your developer fields in Garmin Connect.  Once uploaded, you can update the beta version as many times as you want. When you are ready to release the app, change the app id to your production version in the manifest and upload it without checking the “Beta App” checkbox. Note that the app will have a separate store identifier from your final app, and URLs to the beta will not be visible outside of your account.

    Connect IQ 2.3.1 Now Available!

    06/09/17 @ 10:00 AM

    The wait is over! Connect IQ 2.3 is now available! Here is what’s new:

    • Always Active Watch Faces allow Connect IQ custom watch faces to continuously update every second while maintaining industry leading battery life.This feature is available on fēnix 5/S/X and Forerunner 935.
    • Action Intelligence provides new levels of access to the onboard sensors and allows developers to create metrics for all sorts of activities, like measuring boxing power, tallying tennis racquet swings, rep counting, and more.
    • Background Services opens the ability for Connect IQ apps to periodically operate while the device is idle. These services can communicate over the web, check on sensors, communicate with ANT, and even notify the user of an event.
    • SDK improvements including a new debugger, a new Linux version of the SDK a unit test framework integration with Eclipse, and new additions to the Monkey C language make it easier than ever to develop with Connect IQ.
    • This SDK is the first to support the new Approach S60 Golf Watch.

    What are you waiting for? Get started today!


    Connect IQ Developer Summit 2017 Breakout - Practical App Testing

    05/10/17 @ 01:00 PM

    In this breakout your friendly neighborhood testers teach you tools for testing Connect IQ apps.

    Connect IQ Developer Summit 2017 Breakout - Effective Monkey C

    05/10/17 @ 01:00 PM

    In this breakout Nick, Brian, and Marianne discuss how to take full advantage of the Monkey C language. There is a good discussion of some of these tips on our forum.

    Connect IQ Developer Summit 2017 Breakout - Designing for Garmin Devices

    05/10/17 @ 01:00 PM

    CIQ Summit Logo
    In this breakout you will learn how to design your Connect IQ app from a UX perspective, and how to implement it using the available Connect IQ tools. You can read more after the break.

    Read More

    Connect IQ Developer Summit 2017 Breakout - Survival of the FIT-test

    05/10/17 @ 01:00 PM

    In this breakout Robyn and Greg explain the mysteries of the FIT file format, and how you can use Connect IQ to add new metrics and display them on Garmin Connect. For more information on this topic you can read this blog post on Programmable Web.

    Connect IQ Developer Award - Best ANT Enabled App - Winner

    04/20/17 @ 03:00 PM

    Stryd - Stryd

    Stryd, a foot-mounted power meter, measures your running efficiency, pinpoints your performance bottleneck, and guides you through personalized cardiovascular and strength training, as well as form improvements, so you can improve your efficiency and run faster. Stryd also provides the power-based training intensity control and race-day pacing you have grown to expect.

    Redefine your performance with power-based training by tracking power, improving run form, and letting Stryd guide your performance seamlessly on your watch screen. The Stryd power meter measures your body’s power output in watts, so you can train at the right intensity, pace yourself for optimal race-day performance, and run more efficiently.




    XERT Workout Player Stryd MOXY Trek






    Connect IQ Developer Award - Best EDGE App - Winner

    04/20/17 @ 03:00 PM

    XERT Workout Player - Baron Biosystems

    The Xert Workout Player plays Xert’s unique Smart Workouts. Using Garmin Connect Mobile, the Xert Player logs in to Xert Online, obtains your latest Fitness Signature, downloads your selected workout, configures the exact workout interval intensities and durations specific to you and then plays the workout using your power meter and/or smart trainer. With your smart trainer, it will do trainer control. If you have both a power meter and smart trainer, it will automatically do powermatch and trainer calibration on-the-fly. Playing Smart Intervals, it will auto-adjust interval power and duration, reducing/increasing intensity and slowing/accelerating the timer depending on how an interval is executed in real-time. Easily adjust target power or trainer resistance with swipes / up-down clicks. It will learn your cadence preferences and provide indication of when you’re pedaling too fast or too slow. The app also sends telemetry back to Xert Online so you can view your data online via the Xert Remote Player and follow your workout progress.


    XERT Workout Player JOIN Best Bike Split





    Connect IQ Developer Award - Best Wearable Workout App - Winner

    04/19/17 @ 03:00 PM

    Workout Genius - Robinson Milani

    Is there a workout not represented on your Garmin device? Workout Genius has you covered. Workout Genius provides lots of data fields that are not available in most of the devices. It allows to set up a great variety of screen layouts, has a virtual partner with variable speed, enables to configure the lap size, sounds, vibrations, alerts, and more. And last but not least, it has a multisport mode that supports triathlon, duathlon, swim-run, and aquathlon. All of this is configurable on your device from the Genius Wrist website.


    Shred Deck Workout Genius Race Screen




    Connect IQ Developer Award - Best Wearable Smart App - Winner

    04/19/17 @ 03:00 PM

    dwMap - Marcus Needham

    dwMap allows Garmin users to create routes on the mobile-friendly website as well as import their routes from Strava, MapMyRun, Garmin Connect, Ride with GPS,, GPX and more. You can then sync your routes to your Connect IQ compatible devices, and navigate them using the map. dwMap runs across most Connect IQ devices and at 300K downloads is very popular with Garmin users.


    dwMap WatchOut! Wallet Note 2 Watch Nightscout CGM Watch


    WatchOut! Wallet Team




    Connect IQ Developer Award - Best Watch Face - Winner

    04/19/17 @ 12:00 PM

    Actiface - Petr Koula

    With over 600K downloads, Actiface is by far the most popular app on the Connect IQ store. Customers appreciate its ability to get at a glance the time and a highly configurable dashboard summarizing their health.

    Nominees - Best Watch Face

    Actiface Gear Min No Frills




    The Connect IQ Developer Summit Starts Today

    04/19/17 @ 09:00 AM

    Summit Logo

    The Connect IQ Developer Summit starts today! Over the next two days we’ll be announcing talking about Garmin products, talking to industry leaders, announcing new features, and having a lot of fun. You can follow on the hashtag #ciqsummit17 on Twitter and Instagram.

    Connect IQ 2.3.0 Beta Now Available!

    04/19/17 @ 07:00 AM

    Connect IQ 2.3 beta is now available! The new Connect IQ 2.3 release adds major new features for Connect IQ 2 compatible devices as well as many features for the SDK:

    Always Active Watch Faces
    Other smart watches turn off their screens to save power and still only get a day of battery life. On the new Fenix 5 family and Forerunner 935, your custom watch faces are always on and update every second while still having industry leading battery life.

    Action Intelligence
    25 Hz/3-axis accelerometer access, Finite Impulse Response (FIR) and Infinite Impulse Response (IIR) filters allow developers to create new active lifestyle metrics and use cases.

    Background Services
    Connect IQ apps can now start background services that can do periodic background processing, including communicating with web services, making your smart watch smarter than ever.

    SDK Improvements
    New Connect IQ debugger, Unit test framework integration with Eclipse, and new additions to the Monkey C language make Connect IQ easier to develop for. Also - SDK for Ubuntu!

    Trial Apps - Coming Soon!
    Customers download a locked version of your app, and come to you for the key. Bring Garmin customers to your services using Connect IQ. Contact our developer program for details.

    We’ll be talking about these features at the Connect IQ Developer Summit. Keep watching the blog for updates.

    To get started with the new beta, follow these instructions:

    1. Because we have a beta version of the Connect IQ Plug-in, we encourage developers to download a fresh installation of Eclipse Neon for Java Developers. This separates your beta and production Connect IQ environments.
    2. In the top menu, go to Help > Install New Software
    3. Use the Add… button to add
    4. Check the box next to Connect IQ in the list and hit Next
    5. Dependent plug-in modules may need to be downloaded and installed. When this is complete, restart Eclipse to complete the installation.
    6. Use the steps from the Programmers Guide to configure the plug-in
    7. Use Connect IQ > Open SDK Manager to get the latest SDK

    You can also download beta firmware for the following devices:

    We will update the post as more betas are posted. We’ve been working on this release for a long time and are excited to see what you will create with it. Get started today!

    New SDK and the Connect IQ Developer Awards Nominees

    03/29/17 @ 02:22 PM

    Today we are releasing the Connect IQ 2.2.5 SDK, which adds support for the Forerunner 935 as well as additional bug fixes.

    Get the SDK today!

    With that out of the way, it’s time to announce… (drum roll)...

    Connect IQ Developer Awards

    At this year’s Connect IQ Developer Summit, which will be held at Garmin headquarters April 18th - 20th, we will be presenting the first ever Connect IQ Developer Awards that highlight the content from the Connect IQ Developer Community. The apps were nominated by members of the Outdoor, Fitness, and Connect IQ teams. Only apps developed by developers outside of Garmin qualify for the awards. The nominated apps are below:

    Best Watch Face

    Actiface Gear Min No Frills




    Best Wearable Smart App

    dwMap WatchOut! Wallet Note 2 Watch Nightscout CGM Watch


    WatchOut! Wallet Team



    Best Wearable Workout App

    Shred Deck Workout Genius Race Screen




    Best EDGE App

    XERT Workout Player JOIN Best Bike Split




    Best ANT Enabled App



    XERT Workout Player Stryd MOXY Trek





    The winners will be announced during the summit. If you cannot make the Summit, visit the blog April 20th to see who won in each category. Congratulations to the nominees!


    Connect IQ : Important Updates

    03/15/17 @ 05:59 PM

    There are a few things changing or rolling out in the next few weeks that we’d like all of you to be aware of.

    fēnix® Chronos is now a fēnix 5s

    If you have started development for the fēnix 5s, you will know while it shares the same screen shape and resolution with the fēnix 3 family, the fonts are bolder to be more readable with the smaller screen. If you take advantage of our resource family system, this causes problems when you create apps for the fēnix 3 family and the fēnix 5s; as now you potentially need to keep two resources


    In a future fēnix Chronos update, currently in beta, the firmware will shift from being based on the fēnix 3 to being base on the fēnix 5s. For you Chronos readers out there – congratulations, you’re getting a software upgrade! For Connect IQ developers – congratulations, all of the fonts will change to match the 5s! This has an effect on existing fēnix Chronos apps, as well as new development. For example, now you need three resource directories:


    Clearly this is less than ideal. The Connect IQ team is working on an SDK update that will change the fēnix Chronos simulator to match the fēnix 5s fonts, as well as make it easier to support both devices. Our goal is to make adapting your app to the new fēnix 5s as smooth as possible.

    Changes to makeWebRequest

    Apple introduced App Transport Security (ATS) in iOS 9. From the iOS 9 release notes:

    App Transport Security (ATS) enforces best practices in the secure connections between an app and its back end. ATS prevents accidental disclosure, provides secure default behavior, and is easy to adopt; it is also on by default in iOS 9 and OS X v10.11. You should adopt ATS as soon as possible, regardless of whether you’re creating a new app or updating an existing one.

    If you’re developing a new app, you should use HTTPS exclusively. If you have an existing app, you should use HTTPS as much as you can right now, and create a plan for migrating the rest of your app as soon as possible. In addition, your communication through higher-level APIs needs to be encrypted using TLS version 1.2 with forward secrecy. If you try to make a connection that doesn’t follow this requirement, an error is thrown. If your app needs to make a request to an insecure domain, you have to specify this domain in your app’s Info.plist file.

    Up until now, Connect Mobile has allowed makeWebRequest to communicate over HTTP and HTTPS because it defined the NSAllowsArbitraryLoads permission. However, Apple has a declaration that all iOS 10 apps should support ATS by the end of 2017.

    In light of this, Connect IQ will require that calls to makeWebRequest communicate only with ATS compliant servers.  In a future update the simulator is now going to check to make sure that all requests are talking to properly secured servers, and we will be removing NSArbitraryContent in an upcoming version of Connect Mobile.

    App Store Update

    A number of issues causing the app store mistakenly prevent users from downloading an app because it believes their firmware is out of date have been resolved. As long as users sync their device after they complete a software update they should be able to download the latest content. If you continue to see issues, please let us know on the developer forum.

    Connect IQ Pro Tip: Custom Fonts Tricks

    02/20/17 @ 11:14 AM

    This guest post was written by Hermo Terblanche, a Connect IQ developer in South Africa.

    Have you ever seen an app in the Connect IQ app store that made you wonder, “That is so cool! How did the developer do that?” In order to draw attention to your app you need to stand out from the rest, by for example applying some really cool font tricks. In this blog post I am going to let you in on some of my secrets from my own Connect IQ creations. Hopefully this will inspire you to create your very own jaw-dropping apps for Garmin Connect IQ devices.

    Let’s jump straight into the magic! You’ll need the following tools:

    • BMFont - For exporting fonts to the required format for Connect IQ. You can read more about this in the Programmer’s Guide as well as the UX Guide
    • Graphics editor / Tool - For editing font png files. I prefer to use Photoshop to achieve the desired effects, but they can also be achieved using GIMP

    Font Reflection

    This technique is really simple and could easily be achieved in one of two ways:

    Approach A

    For the watch face Summer Sunset, I used a free font called Sunset that I downloaded and exported to a PNG using BMFont.

    This font combines each number and its corresponding reflection into a single glyph. This means that when you draw a number, it draws both the number and reflection as a single character.

    The benefit of this approach is efficiency: you only need a single font which requires fewer resources and results in a smaller compiled PRG file. Also, your code also runs cheaper as you only need a single statement to draw the number which is more battery friendly. Finally you don’t have to separately manage the positioning of drawing a number’s reflection, making this the simplest approach.  The downside is that you cannot have separate colors for the number and its reflection because the glyph is treated as one atomic character, and only one color can be applied to the glyph as a whole.

    To see the skyline behind the time, you first draw the skyline, then you specify a transparent background color for the font and finally draw the time on top of the skyline:

    //draw skyline here
    //load custom font
    var font = Ui.loadResource( Rez.Fonts.Sunset );
    //set the time's color and draw it
    dc.drawText(timeX,timeY, font, timeStr, Gfx.TEXT_JUSTIFY_CENTER);

    This approach is the most straightforward and does not need any further image processing of the font once it has been exported using the BMFont tool.

    Approach B

    The Reflection watch face is a bit more advanced and involves some image processing, but it offers the benefit of specifying a different color for the time and the reflection.

    This approach uses two separate fonts. For this I also downloaded a free font and exported it to a PNG using BMFont. I then duplicated the *.PNG and *.FNT files and renamed them to something meaningful so I could easily distinguish between the files of the two different fonts. Using some Photoshop skills I transformed each glyph in the duplicated PNG file to look like a reflected character. It is important to keep in mind with this approach is that it works best with a monospaced font; having constant glyph sizes in both fonts makes it easier to align the normal and reflected time when drawing. Without going into too much detail about the exact image processing steps, here is a basic outline of what to do:

    • For each glyph (one at a time):
      • Use the selection tool to select a glyph
      • Use the transform menu and flip the selection vertically
      • Using the transform menu, either skew or distort the selection to get the desired angle of the character. Keep in mind that you cannot skew too much because you want the reflection of the time to still fit within the screen. In the screenshot above you will notice that the bottom of the reflected “1” touches the screen boundary. A more skewed effect will cause the reflected “1” to be clipped. You have to experiment a few times to get it right. This step is the most challenging, but also the most rewarding one!
      • You have to move the transformed selection to align it alongside other transformed glyphs. This makes it easier to specify the character coordinates in the *.FNT file.
    • Save the png for the reflection font once all glyphs have been transformed.
    • In Photoshop, use the selection tool to find the new x, y coordinates for each transformed glyph, and change the corresponding values in the duplicated *.FNT file.
    • Make sure to point the file property in the duplicated *.FNT file to the duplicated *.PNG (reflected font).
    • In code load your two fonts, and after you’ve drawn the normal time, you draw the same time using the reflection font. For the reflected time, you need to align the characters with the bottom of the normal time’s characters.

    Below is an illustration of some of the glyphs from the normal font and their corresponding reflected glyphs in the reflection font.

    //load custom font for the normal time
    var normalFont = Ui.loadResource( Rez.Fonts.Normal );
    //load custom font for the reflected time
    var reflectedFont = Ui.loadResource( Rez.Fonts.Reflected );
    //set the normal time's color and draw it
    dc.drawText(timeX,timeY, normalFont, timeStr, Gfx.TEXT_JUSTIFY_CENTER);
    //set the reflected time's color and draw it
    dc.drawText(offsetX,offsetY, reflectedFont, timeStr, Gfx.TEXT_JUSTIFY_CENTER);

    Fonts With Two Colors

    Connect IQ supports only one color in custom fonts. This is because the font’s PNG is a grayscale image and therefore has only one channel. You cannot create a font to display multiple colors. Below is an illustration of the concept that is not possible within a single font:

    But fear not! With some clever tricks it is possible to create the effect of a font that displays multiple colors. The watch face Watch Me displays its time using two colors: white border and blue fill.

    The magic behind this trick involves a combination of two fonts with different masks. Below is an illustration of some of the glyphs from the two different font masks. The top image is the font for the border, while the bottom font is for the inner fill. An easy way to remember which is which, is to remember that white is the area that will be drawn onto the screen in a color of your or the user’s choice.

    The top mask is the original font that was exported using the BMFont tool. For the bottom mask I created a duplicate of the top mask, and then basically inverted the colors to ensure it will only draw the inner area in a specific color.

    //load custom font for the border
    var borderFont = Ui.loadResource( Rez.Fonts.Border );
    //load custom font for the inner fill
    var innerFillFont = Ui.loadResource( Rez.Fonts.InnerFill );
    //set the time's border color and draw it
    dc.drawText(timeX,timeY, borderFont, timeStr, Gfx.TEXT_JUSTIFY_CENTER);
    //set the time's inner fill color and draw it
    dc.drawText(timeX,timeY, innerFillFont, timeStr, Gfx.TEXT_JUSTIFY_CENTER);

    Font With a Diagonal Orientation

    The idea to write text with an orientation other than horizontal is not something I innovated; I first saw it in another watch face in the store. Being a curious developer I had to try it out myself. The result of this experiment can be seen in my watch face South Africa. The time is displayed diagonal in either an ascending or descending orientation based on a user’s preference. Each orientation is created with its own separate font.

    You need to apply a rotation factor to each glyph in your font PNG. Rotating the glyphs will result in glyphs that are slightly bigger than the original. Below is an illustration to get an idea of what the PNG for each font looks like after all glyphs have been rotated:

    When drawing text diagonally, you can no longer draw the string as a single entity; otherwise you’ll just end up with a horizontal line of text with tilted characters, similar to what you now see in the above illustration. The real trick is to draw each character individually, but for each character adjust the y and x coordinates appropriately. For descending orientation, you need to increase the y coordinates, and for ascending you need to decrease it. The x coordinate will always increase in both scenarios. The glyphs have to overlap each other in order to create the diagonal effect. This is where a transparent background color does the trick!

    The angle of rotation that you would like for your font is all up to you and you can experiment with different degrees of rotation in your graphics editor. In order to know where to draw the next character, you could maintain an array of coordinates. It is a lot easier to manage and draw diagonal text using a monospaced font because any character can be drawn at the same coordinate without causing gaps of varying size between adjacent characters.

    //predefined coordinates based on diagonal angle and orientation
    var ascCoords = [[21,143],[42,129],[62,119],[73,108],[93,95]];
    var descCoords = [[21,34],[42,48],[62,58],[73,69],[93,82]];
    //set background color transparent to prevent clipping of characters
    dc.setColor(Gfx.COLOR_WHITE, Gfx.COLOR_TRANSPARENT);        
    //string to be drawn
    var time = clock.hour.format("d") + ":" + clock.min.format("d");
    var coords, font;
    //determine the font and coordinates to use based on orientation
    if(Orientation == “Descending”){
    	coords = descCoords;
    	font = Ui.loadResource(Rez.Fonts.fontDesc);
    	coords = ascCoords;
    	font = Ui.loadResource(Rez.Fonts.fontAsc);
    //draw each character individually
    for( var i = 0; i < time.length(); i++ ) {
    	var char = time.substring(i,i+1);
    	dc.drawText(coords[0], coords[1], font, char, Gfx.TEXT_JUSTIFY_LEFT);

    Dynamic Color Filling

    In my signature watch face NoFrills, I use an easy trick to create a special effect that makes the time fill up with water. It effectively serves as a progress gauge for activity tracking, while at the same time conserves real estate on the screen. Talk about a dual-purpose clock!

    You only need a single font for this trick, and best of all: there is no image processing required. Only the power of Connect IQ is enough to achieve this! Again, a monospace font provides the best results and is simpler to work with.

    1. Determine the size and coordinates of the area (rectangle) that the text you would like to draw, will occupy on the screen.
    2. Draw a filled rectangle of this size at the predetermined coordinates. The color of this rectangle should be the color that you would normally have used for the text.
    3. Draw any special effects on top of the filled rectangle, but before you draw the text. In NoFrills’ case, I draw the filled rectangle that represents the water level.
    4. Set the foreground color of your text to transparent and the background color to something else, like the background color of the screen. This effectively creates a mask that clips everything you have drawn in the previous steps.
    5. Now draw your text on top of it all, compile and run it and finally stare in awe at your amazing production!
    //load custom font
    var font = Ui.loadResource( Rez.Fonts.MyFont );
    //draw filled rectangle to represent text’s color
    dc.setColor(Gfx.COLOR_WHITE, Gfx.COLOR_WHITE);
    dc.fillRectangle(rectX, rectY, width, height);
    //draw filled rectangle to represent water level
    dc.setColor(Gfx.COLOR_BLUE, Gfx.COLOR_BLUE);
    dc.fillRectangle(effectX, effectY, width, effectHeight);
    //create and draw the clipping mask
    dc.drawText(timeX, timeY, font, timeString, Gfx.TEXT_JUSTIFY_CENTER);

    You can find Hermo on Twitter, Facebook, Instagram, and the Connect IQ Developer Forum. See Hermo’s Connect IQ apps in the Connect IQ Store.

    Connect IQ - BLE Direct Messaging Updates

    02/09/17 @ 04:55 PM

    The BLE Direct Messaging link feature of the Connect IQ SDK has received an overhaul with a focus on:

    • Reduced data transfer latency
    • Ability to remotely launch an application on the watch

    All wearable devices (except for Epix) support these features as of the Connect IQ 2.2.3 SDK and Android / iOS Mobile 1.3 SDK releases.

    Faster Data Transfer

    A new lower latency API for direct messaging is now available for watch apps that communicate directly with a phone app via the Connect IQ Mobile SDK. These apps will receive a speed boost once they implement the new registerforPhoneAppMessages API, which is used to receive messages from a phone app. The behavior of this new API should be familiar with users of registerForOAuthMessages, since it shares the same base Message type. If messages are received when no callback is registered with this API, they are saved on the device until the storage limit for messages is reached. Any messages that are saved on the device will be sent to the specified callback after it is specified in registerforPhoneAppMessages. The transmit API is used to send messages directly to a phone app. A connection listener is registered with each transmit to receive the status of the attempted transmission:

    //! Register a callback for receiving Phone App messages. The callback will be called
    //! once for each message received. If there are messages waiting for the app when this
    //! function is called, the callback will immediately be called once for each
    //! waiting message.
    //! @param method [Method] The callback with the signature callback(data). Data will be of
    //!                        type PhoneAppMessage
    //! @since 1.4.0
    native function registerForPhoneAppMessages(method);
    //! Send data across the the BLE link.
    //! @param [Object] The object to be sent
    //! @param [Dictionary] options Additional transmit options (TBD)
    //! @param [ConnectionListener] listener An extension of the
    //!       ConnectionListener class.
    function transmit( content, options, listener );
    //! Listener class for transmit
    class ConnectionListener
        //! Callback when a communications operation error occurs.
        function onError();
        //! Callback when a communications operation completes.
        function onComplete();

    The existing mailbox API has been deprecated in ConnectIQ 2.2 and registerforPhoneAppMessages should be used instead for the aforementioned performance gains. An example of using both together in practice:

    using Toybox.Communications;
    class Example {
        function initialize() {
            var mailMethod = method(:onMail);
            var phoneMethod = method(:onPhone);
            if(Communications has :registerForPhoneAppMessages) {
            } else {
        // @param [MailboxIterator] mailIter
        function onMail(mailIter) {
            var mail =;
            while(mail != null) {
                // Do something with mail
                mail =;
        // @param [PhoneAppMessage] msg
        function onPhone(msg) {
            // Do something with

    The setMailboxListener and registerForPhoneAppMessages APIs are mutually exclusive and cannot be used at the same time in an app. If both listeners are registered, the deprecated mailbox listener will not receive any callbacks; messages will only be sent to the registerForPhoneAppMessages listener.

    Opening an App on a Watch

    The 1.3 updates for both the iOS and Android Mobile SDK’s allow you to prompt the user to open a Connect IQ application on their device. If the user chooses to open the app then it will be immediately opened. Only watch-apps may be launched remotely; launching widgets, data-fields and watch-faces is not supported.


    For Android you can use the openApplication API to request the remote launch. A response from the device will be returned to your IQOpenApplicationListener:

    connectIQ.openApplication(device, app, new IQOpenApplicationListener() {
        public void onOpenApplicationResponse(IQDevice device, IQApp app, IQOpenApplicationStatus status) {
            // Handle the response here

    See the Comm sample application included with the Android Mobile SDK for an example implementation.


    For iOS you can use the the openAppRequest: method to request the remote launch:

    [[ConnectIQ sharedInstance] openAppRequest:app
                                    completion:^(IQSendMessageResult result) {
        switch(result) {
            case IQSendMessageResult_Success: NSLog(@”Popup was displayed”); break;
            case IQSendMessageResult_Failure_PromptNotDisplayed: NSLog(@”Popup was
                    displayed”); break;
            case IQSendMessageResult_Failure_AppAlreadyRunning: NSLog(@”Popup was
                    displayed”); break;

    See the ExampleApp sample application included with the iOS Mobile SDK for an example implementation.

    What’s Next?

    Both of the samples included with the Android / iOS Mobile SDK’s have been updated to support remotely launching Comm sample from the Connect IQ SDK, which also now supports new registerForPhoneAppMessages API for faster communication. Get the SDK’s today to start playing with the new features!

    Connect IQ Top Apps: Jan 2017

    02/03/17 @ 08:31 AM

    We are trying out a new thing where we publish the most popular apps of the month. Note that this list is meant to promote your hard work, and removes Garmin apps, pre-loaded apps, and featured apps from the list. The “Buzzed” column includes apps that people found via social media.

    Place Watch Face Data Field Widget App Buzzed


    Single Run Field

    Battery Meter





    Heart Rate Zones Chart

    Compass G2

    Maps r.485

    Maps r.485


    No Frills

    Race Screen


    Cycling App Professional

    7-Minute Workout

    Connect IQ 2.2.4 Now Available!

    02/01/17 @ 11:45 AM

    Connect IQ 2.2.4 is now available! The big changed items are:

    • Fixed a compiler bug where launcher-icon resources could not be properly overridden using device families.
    • Added support for APAC Fenix5 devices
    • Updated minimum firmware versions for the vivoactive HR

    Download the SDK today!

    From One Platform to Another : Tales of a Pebble Refugee

    01/25/17 @ 03:15 PM

    Today’s post was written by Franco Trimboli, an Australian developer who has published a number of apps for the Pebble platform. He’s recently begun developing apps for Connect IQ and has written this guest post about his experiences.

    For many, the Pebble was the first smartwatch they would own. With all the fanfare of a record-breaking Kickstarter campaign, the original Pebble opened up a world of notifications - right there on your wrist. And of course, custom apps. Most developers, including me, jumped at the opportunity to be part of this new community of user friendly, wearable computing.

    Fast forward to the present, and sadly Pebble is no more. The health features and long battery life had me keen on replacing my Pebble with something similar.

    Being a wearable tech nut, I purchased a Garmin fēnix® 3 right around the same time as my Pebble Time. Like it’s namesake, the fēnix emerged from the dark corner of my drawer and became my daily watch. Now while I love my fēnix 3, other hardware in Garmin’s wheelhouse delivers a more Pebble-esque experience; I recently played around with a vívoactive® HR and it’s like the love child of a Pebble Time and Pebble 2 with an always on color touch screen.

    Previously, my reluctance to wear the Garmin rather than the Pebble came from my initial experience with Garmin’s back then embryonic ecosystem. Well, I’m happy to say much has changed since. I was immediately surprised with how far Garmin’s ecosystem has evolved. In particular, Garmin’s SDK — Connect IQ (CIQ) — has come a long way. The discovery of Garmin’s Forum, which delivered helpful insights by seasoned CIQ developers, was a turning point for me. It clearly made me understand how rich the Garmin ecosystem is — widgets, data fields, wireless sensors, apps, and of course, watch faces.

    The CIQ learning curve isn’t too hard. If you’ve ever built a Pebble watch face — either in C, or Rocky.js — you’ll find the transition relatively straightforward. Monkey C is an OO language, and unlike C on the Pebble, Monkey C runs in it’s own VM and performs it’s own memory management through reference counting. The CIQ dev environment is integrated with Eclipse. However, I’m not a fan — so I tend to code in a shell, just like the Pebble cmdline and QEMU.

    If you’re curious, here are some of the watch faces that I’ve built over the past few weeks.

    More Similar Than Different

    If you’ve developed apps on Pebble’s SDK — or even if you’ve just messed around with a few watch faces — building on Garmin’s CIQ should be a cinch. In this post, I’ve tried to outline a few helpful hints on the similarities and differences of both platforms:

    Package.json is now Manifest.xml

    Analogous to Pebble’s package.json, the manifest.xml in CIQ provides essential information about your app. At a high-level, it allows you to define the devices, the access privileges, as well as the device capabilities to be supported — it also instructs the run time on the entry point of your your app (think main() on the Pebble).

    Battery Life

    Garmin’s background is in making wearables for athletes, where long battery life is essential. CIQ devices run in a low power mode most of the time, and return to high power mode when the user wakes up the device with a button tap or gesture. As such, watch faces only (usually) update on minute increments. 

    On a Pebble, you have the flexibility of managing the update interval with tick_timer_service_subscribe with the granularity of a second. In CIQ, watch faces implement the onUpdate method to handle display update events from the system. While this seems like a limitation, it makes sense when your objective is to save battery. The good news is that CIQ provides the onExitSleep and onEnterSleep events so that developers can trigger something useful on the screen like a field update or animation. It’s analogous to the accel_tap_service_subscribe event on a Pebble.


    Continuing with the theme of battery life, watch faces are limited to certain API features so they can’t do things like retrieve weather or stock data. While this may seem limiting, Garmin’s approach is to use purpose built widgets to deliver weather and news. Widgets in CIQ take us back to Pebble OS 1.0 — where you could flick through different “apps” by scrolling up and down. Widgets are a great way of accessing data without having to bake it all into a watch face or launch an app.

    However, CIQ does have some tricks up its sleeve. Widgets or apps can do things like make web requests in ways you’re familiar with — but with less setup and coding. Normally, on the Pebble you would offload this via XMLHttpRequest through pebble-js and then handle the event with events_app_message_register_inbox_received. With CIQ, this is managed neatly in one place with makeWebRequest with an async callback, allowing you to do some interesting things like manage the request payload from within the logic of your app without having to manage code in two different codebases/languages. 

    CIQ can also grab, downsample and render an image from the network using makeImageRequest. So you can build cool things, such as grabbing the latest frame from a network security camera, without having to do all the heavy lifting.


    As Pebble apps are built in C, they require careful management of memory. Pebble’s SDK uses functions suffixed with _destroy to do this, ie; to remove a typical screen from memory, you’ll be running bitmap_layer_destroy, gbitmap_destroy, and text_layer_destroy — as a minimum.

    As CIQs runtime is reference counted, the Monkey C VM manages most of this for you. Clearing objects usually only requires that you set them to “null”. Also, as an object-oriented language, you gain the advantage of objects, class inheritance, etc. That being said, CIQ has helper methods to keep an eye on the memory ceiling.

    While, both Pebble and CIQ support 64kb per watchface, more recent Garmin devices offer up to 128kb of memory for apps.


    Just like on a Pebble, you can define and access custom image bitmaps and fonts. On the Pebble platform, you’d define resources - and their corresponding IDs - within the resources item in package.json. You would then access those resources via their names or handle IDs within your code.

    Similarly, CIQ defines resources this way, but within an XML file known as resources.xml. CIQ also allows you to define platform specific resources using separate resource directories - for example, using resources-round-218x218 to support all round watches with a resolution of 218 x 218.


    Likewise with Pebble, images are converted and stored internally as 1, 4, or 8-bit formats. This allows you to support many devices and bit depths from 2 colors to 64 colors.

    On the Pebble, you’d manage the bit-depth of images via memoryFormat in package.json. Within CIQ, it’s a little easier. All you need to do is define the colors you want to display (as hex values) within a <palette> node from within your resources.xml file. The nice thing about CIQs approach is that the resource compiler handles the rest, including the re-sampling and dithering. This saves you generating many different image types and bit depths.

    In your code, loading bitmaps uses the unified resource method; loadResource(Rez.Drawables.RESOURCE_ID) which corresponds to Pebble’s more specific gbitmap_create_with_resource(RESOURCE_ID) method.


    Pebble made it easy to include TrueType fonts within your app. You’d define unique resource identifiers - ie; FONT_VERDANA_BOLD_42 - and the compiler would go away and create a 1-bit bitmapped version of the font. Multiple resource identifiers (BOLD_16, BOLD_42) were needed for each glyph size which increased memory usage.

    It’s a little more involved with Garmin. CIQ requires that you first convert the TTF to a bitmap font in the FNT format. This generates an image bitmap, with the font glyphs, and a descriptor file. Luckily, the Garmin folks reference a conversion tool, and there’s a number of open source FNT converters out there. Personally, I prefer the Garmin way, as you can edit the bitmap, and add custom glyphs and icons. In fact, my Segment watch face is built pixel-perfect from a bitmap font I hand-crafted.

    On a Pebble you access your fonts through fonts_load_custom_font(resource_get_handle(RESOURCE_ID)). On CIQ, you use the unified resource method, as before, to load your fonts; loadResource(Rez.Fonts.RESOURCE_ID).

    Frame Buffer

    Unlike Pebble devices, you don’t have direct access to the frame buffer / canvas. You can only write to the screen using text, bitmaps, and dot / line / polygon primitives. While this seems limiting, the reality is that you seldom need to do any hardware level byte-blitting on the screen.

    Layout engine

    One of the advantages of Garmin’s platform, is the built-in layout engine. Unlike the Pebble ecosystem, Garmin has many different devices with a multitude of screen sizes and resolutions. The layout engine makes it easy to define one or more responsive views, including text fields, data fields, and images.

    Properties and Settings

    CIQ allows watchfaces and apps to define and store their own properties. This is handy to store and edit user settings. Pebble has a 4kb limit, while CIQ allows up to 8kb per app.

    With Pebble, there’s a few ways to do this - through the Persistent Storage API, or via Clay. Using Clay you’d define your apps properties using messageKeys within package.json - and then define how they’re configured through a Clay config.json file. Then within your app, you’d define the values within a struct, and register app_message_register_inbox_received to read tuples from a dictionary. To persist settings, you’d then call persist_write_data to store your properties.

    On CIQ, it’s a magnitude easier. Properties have unique keys and types (Number, String, etc) which are defined within a properties.xml file. The corresponding settings are defined within a settings.xml file, referencing the property keys you wish to expose to your users. Accessing properties and settings is as simple as calling a getProperty method in your app. Whenever a user changes a setting, the onSettingsChanged method is called, allowing you to register any callbacks to update your app.

    Starting with examples

    There’s nothing like traversing through other people’s code when you’re learning the ropes of a new platform. Garmin recently published a three part series (part 1/part 2/part 3) that overviews creating an app from recording metrics to UI development, as well as a sample on using the OAUTH system. You can also download a free e-Book that gives an overview of the Connect IQ system.

    I’ve made my Nyan Cat watch face open source — feel free to grab it on GitHub and play around with it.


    While it’s too soon to tell, the team at Garmin seems responsive and willing to listen to issues and feature requests from both users and developers alike. The CIQ team are great listeners, and are willing to consider features that developers want no matter who proposes them. In many ways, this feels similar to the early days at Pebble. While there’s a smaller dev community, in general folks seem more willing to help out, and share their code & knowledge at the drop of a hat.

    This year, Garmin seems poised to give their developer community a new opportunity to flourish. Only recently, they announced a 3-day dev summit at their HQ, and they’re (amazingly) giving away devices like the fēnix 5 to developers! It’s a good opportunity to rub shoulders with like-minded developers, and learn the ropes about building apps in the wearable space.

    So, if you’re a Pebble refugee and you’ve got the itch to build something useful — or just plain fun — give the SDK a whirl, and join the emerging group of developers building on this platform.

    Connect IQ 2.2.3 Now Available!

    01/04/17 @ 01:23 PM

    Fenix 5

    Connect IQ 2.2.3 is here! This version adds support for the new fēnix 5 family, the latest Connect IQ compatible multisport wearables announced at CES. The fēnix 5S is lighter, sleeker and smaller than previous models – perfect for small wrists without sacrificing multisport functionality. The fēnix 5X boasts preloaded wrist-based mapping; and the compact fēnix 5, like other fēnix watches, is feature-packed and ready to take on any adventure with an all-new industrial design. All of the fēnix 5 models are 24/7 wearable with extended battery life, daily activity tracking, Garmin Elevate™ wrist heart rate technology, and a host of connected features. And users can easily switch between stylish leather and metal accessory bands to sporty silicone in seconds and without tools, thanks to the new QuickFit™ bands.

    You can see the new capabilities of the devices in the table below:

    Device Resolution (px) Icon Resolution Colors Available Button Functions Screen Type Touch Screen
    fēnix™ 5S 218 x 218 40 x 40 64 up, down, enter, back, menu round No
    fēnix™ 5, fēnix™ 5X 240 x 240 40 x 40 64 up, down, enter, back, menu round No

    Note - we will not be auto-migrating apps to the Fenix 5 family. Get the SDK today to develop for the Fenix 5!


    Also exciting is the new UBER ETA app by Garmin. Uber ETA lets you check your driver’s pickup ETA, driver details, and the ETA to your destination on Garmin wearables that the same way you check the time: with a flick of the wrist.
    UBER ETA by Garmin

    The first time you run the application, you will need to log into your Uber account through the Garmin Connect Mobile application. Once you’ve completed the login, any time you request an Uber, the ETA app will show you the time until your ride arrives, guide you to your pickup location, and keep you updated on your ETA during your ride.

    UBER ETA by Garmin is available today on the Connect IQ store.

    Connect IQ 2.2.2 Now Available!

    12/21/16 @ 02:48 PM


    Connect IQ 2.2.2 is here! This release adds a new feature we are very excited about: remote app launch. Users of the Mobile SDK can now request their Connect IQ app be launched from an Android or iOS app. If the device is able to handle the request (has the app, isn’t currently running an activity or app), the user will be presented with a notification asking if they want to launch the app in question.

    Remote launch

    This SDK addresses a number of reported issues in the Mac and PC SDK. There are corresponding updates to the Android and iOS mobile SDKs as well. Download the SDK today!

    Connect IQ Summit : Apply Today

    12/15/16 @ 12:59 PM


    We are now taking applications for the first ever Connect IQ summit! Held at Garmin HQ on April 18 - 20th, 2017, this summit will feature workshops by the Connect IQ team, talks from Garmin and industry leaders, and one of a kind networking events. Participants also get a free Connect IQ device!

    Space is limited, so apply today. Hope to see you there!

    Connect IQ 2.2.1 Now Available!

    11/08/16 @ 11:10 AM

    Looking for a break from non-stop election news? Connect IQ is here for you!

    Connect IQ 2.2

    Connect IQ 2.2.1 is now available. This update is targeted for Connect IQ compatible Edge®, Rino®, and Oregon® devices.  Devices now get support for Connect IQ Intents, PersistedContent, and the new AntPlus. The big news for the Oregon and Rino is that they now support Connect IQ 2.x including widgets and apps! Get the SDK today and get started!

    Wearable Programming for the Active Lifestyle

    The Connect IQ book, Wearable Programming for the Active Lifestyle, is now available… for free! This e-book covers topics like wearable programming, web services, ANT, activity recording, and the wearable future. And did we mention that it’s free? Get the book today!

    A Connect IQ Halloween

    11/02/16 @ 11:14 AM

    My Buddy and Me

    Hope you all had a happy Halloween. Here at CIQ HQ we had the annual department Halloween donuts/costume competition. One of the winning entries was the Face-It™ Machine, an anthropomorphized version of the Face-It app. The Face-It Machine came complete with pre-made watch faces of various team members.


    From the Garmin Cochrane office came this adorable costume: a Portal Sentry Turret!

    Read More

    Connect IQ 2: Intents and Persisted Content

    11/01/16 @ 10:34 AM

    Connect IQ 2.2 adds Intent objects, which allow a Connect IQ app to launch another app or a native activity from a running app. It also opens up access to the device’s native content like the user’s waypoints and courses, as well as adds the ability to download native content from the cloud to a device. This allows developers to create Connect IQ apps that curate content, and launch into the native activity. This post provides an overview of these new features and how to use them.

    Read More

    Connect IQ 2.1.5 Now Available!

    10/18/16 @ 03:44 PM


    Connect IQ 2.1.5 is here! This point release updates the minimum firmware version for a number of devices.  Get the SDK today!

    Connect IQ Developer Summit

    10/10/16 @ 06:49 PM

    We are excited to announce the first ever Connect IQ developer summit! Join the growing Connect IQ developer community with the first Connect IQ Developer Summit at Garmin Headquarters in Olathe, Kan. Sign up now to stay informed of the latest news and be ready for this exciting event.

    Connect IQ 2: Connect IQ 2.2.0 Beta Now Available!

    10/06/16 @ 11:00 AM

    Today the Connect IQ team is proud to announce the next update to Connect IQ 2. This update is for Edge and Oregon products, and adds exciting features to the Connect IQ platform.

    Read More

    Connect IQ 2.1.4 Now Available!

    09/27/16 @ 01:12 PM

    Connect IQ 2.1.4 is here! This point release fixes some issues with the toolchain and updates the minimum firmware version for a number of devices.  Get the SDK today!

    Connect IQ 2.1.3 Now Available!

    08/31/16 @ 02:33 PM

    A new Connect IQ SDK is now available! This update adds support for the fēnix Chronos, a premium version of the popular multisport watch.

    Read More

    Connect IQ Pro Tip: Using the Bitmap Palette Options

    08/15/16 @ 08:33 AM


    In our world of HTML, megapixels, and gigabytes it can be easy to forget the resource usage of bitmap images. Connect IQ's constrained embedded environment requires developers to consider the cost of bitmaps when making pages. Thankfully, the Connect IQ SDK provides a number of tools to control your image costs while make a great looking app.

    Read More

    Connect IQ 2: The Biker Has Arrived

    08/08/16 @ 09:45 PM

    Biker Monkey

    We are go for launch! Today we are releasing the new Connect IQ 2.1 (Biker Monkey) SDK that allows developers to upload apps to the Connect IQ store. This SDK allows you create apps for all Connect IQ compatible devices. Device firmware is rolling out to add functionality to most of our Connect IQ devices. This is by far the biggest Connect IQ release we have ever done, and we’re excited to see what you create with it!

    Read More

    Connect IQ 2: New Toys in the Toybox

    08/08/16 @ 01:14 PM


    We have covered a number of the new additions for Biker Monkey, including the new security system, widgets and apps on the Edge, the new test framework, how to show data to Garmin Connect, and support for OAUTH authentication. Even with all that, there are still some features we haven’t discussed yet.

    Read More

    Connect IQ 2: Authentication

    08/04/16 @ 04:51 PM

    throws StringNotTautException

    Today there are countless web services available to developers, but up until now most have been inaccessible to Connect IQ developers. The reason is that these services use either OAUTH 1 or 2 to provide access control, and this functionality did not exist in Connect IQ. Biker Monkey adds new OAUTH APIs into the Communications module that allow widgets and device apps to make authenticated calls. We’ve also added this feature into Aikido monkey, so you can use this in your 1.x apps as well.

    Read More

    Connect IQ 2: The Full Circle

    08/02/16 @ 05:07 PM

    One of the most exciting new features in Aikido/Biker Monkey is the ability to contribute workout information. Data Fields and device apps will now be allowed to record new information to the current activity and have that information displayed on Garmin Connect. This will open up the ability to record new metrics from ANT sensors, contribute new workouts, and support entirely new activities both on the device and in the cloud. We call this the “Full Circle Experience”: your app now can be downloaded to a device, record information, and be shared on Connect.

    Read More

    Connect IQ 2: Run No Evil

    07/26/16 @ 08:21 AM

    Magic Monkey!
    For more advanced testing and debugging capabilities, the Connect IQ 2.1 SDK adds Run No Evil, an automated unit testing framework found in the Test module. Run No Evil operates only within the Connect IQ simulator and provides the ability to add asserts and unit test methods to your app. These tools allow you, the developer, to create higher quality apps by letting us do the testing work for you!

    Read More

    Connect IQ 2: Widgets and Apps on Edge®

    07/14/16 @ 06:47 PM

    Cycling Monkey
    The Edge platform is introducing application and widget support as part of the Connect IQ 2.1 launch! A whole suite of features previously found only on watches, such as Communications, Input Handling, Menus, and Progress Bars, will now be available to Edge devices. These features enable developers to create all-new and exciting content focused on our cycling user’s lifestyles.

    Read More

    Connect IQ 1.2.11 Now Available!

    07/13/16 @ 02:50 PM

    EDGE 820
    Connect IQ 1.2.11 is now available! In this release we’ve added support for the new Edge® 820 and Edge® Explore 820. Featuring advanced navigation, powerful performance measurements and all new group live tracking, our 2 newest cycling computers also have Connect IQ compatibility. Now is the time to start working on data fields that could be used by thousands of serious cyclists around the world.

    Read More

    Connect IQ 2: Security

    06/17/16 @ 01:08 PM

    Connect IQ

    At Garmin we are focused on the security of our devices and our services.  As Connect IQ grows and expands on the functionality and user identifiable information available on our devices we have overhauled our security model.  This new security model in Connect IQ 2 is built to give the developer and the user the tools to know that their device and their information is safe with Garmin.

    Connect IQ 2 introduces new levels of trust for apps:

      Trusted - Content that has been approved by the app store. These apps have passed the Garmin review process and was downloaded from the Connect IQ store.
      Developer - Content that has been written by an individual developer, but has not been published by the Connect IQ store. This content can be used for testing, but is not an officially released app.
      Untrusted - Rabble. Should not be run on device.

    These levels of trust are enforced using digital signatures. A new key management system has been worked into the app store, the device, and the developer SDK. The goal is to make sure that apps loaded from developers only come from two locations - the app store or a trusted developer.

    Read More

    Connect IQ 2: Biker Monkey

    06/15/16 @ 10:35 AM

    Biker Monkey

    The Connect IQ team is thrilled to present a preview of our next generation SDK: BIKER MONKEY. This is the biggest Connect IQ update we have done since launching in 2015.

    Read More

    Connect IQ Mobile SDK: Connecting to a Device

    05/25/16 @ 04:07 PM

    The first step to writing a partner powered Connect IQ app is getting your partner app and Connect IQ app connected. The Partner SDK provides the tools for you to do this how you feel it best fits into the flow of the app. We’re going to take a look at a couple different approaches using the Disc Golf sample featured in this previous blog post.

    Read More

    Forerunner 735 and Strava Suffer Score

    05/10/16 @ 09:27 AM

    Today we are announcing the next Connect IQ compatible running watch, the Forerunner 735XT.

    The Forerunner 735XT, a GPS running watch with multisport features and wrist-based heart rate. The most lightweight multisport-capable running watch from Garmin, the Forerunner 735XT features 24/7 heart rate monitoring and built-in activities including running, cycling, swimming, multisport, hiking, XC skiing, strength training, paddle sports and cardio.  This is going to be a very successful watch that meets the demanding needs of long distance runners around the world. 

    Today we are also excited to announce the expansion of our partnership with Strava to bring their premium Suffer Score feature to Garmin devices for the first time with Connect IQ.  Download it today: Strava Live Suffer Score

    Read More

    Updated FIT SDK

    04/12/16 @ 12:33 PM

    We are pleased to announce the upcoming release of the FIT SDK 2.0!

    This release includes many small upgrades to enhance performance and functionality, but the star of the show is the addition of customizable data fields. Developers have long requested the ability to add dedicated metrics to highlight their specialized programs — and we listened. The new data fields can be coded to your specifications and then easily shared with other FIT developers.

    Moving forward, most devices will primarily support the creation of FIT 2.0 files, so if you intend to continue development using FIT files, then it is very important that you update. If you do not update, your program will not be able to correctly decode the new 2.0 files without breaking your application data flow.

    This exciting update is currently scheduled to release in Q2 2016 but please feel free to visit the site to see if we release an early beta version - wink wink.  Please join the discussion at our FIT forums located at to address any questions or concerns you have.

    We look forward assisting in your success as you continue to Build Something with Us!

    EDGE Data Fields Available Today!

    03/10/16 @ 10:12 AM


    Connect IQ is now ready to be on the handle bars of over 500,000 EDGE devices around the world. This is the capability that our EDGE owners have been anxiously awaiting and the day has come. All they have to do is to update their firmware which is pretty automatic and they are set for your data fields. With this update the EDGE 1000, Explore 1000 and EDGE 520 will all be compatible with Connect IQ. To update your compatible Edge device so you can start using Connect IQ please use Garmin Express.

    With EDGE data fields you will have all of the capabilities that you have on the wearables. All of the same sensor data, APIs and UI tools are available. But we do have some exciting news about data fields on the Edge. You can now use generic ANT within the data field! That means bringing in new sensor data into the data field experience. This is big news for a lot of our innovative partners around the world.

    Specialized Turbo LEVO Data Field


    We are excited to launch this new feature of our EDGE devices with Specialized Bikes as they launch their new Turbo LEVO e-mountain bike. The Specialized Turbo Levo features all the hallmarks the Specialized mountain bikes are known for while streamlining Turbo technology integration to give you the power to ride more trails. With the Specialized Turbo Levo Connect IQ Data Field you have the opportunity to extend and customize your display.

    The Connect IQ Data Field displays all Turbo Levo specific information like bike state of charge, current assist mode or rider input power. Even better, it also allows you to control and switch the Eco/Trail/Turbo assist modes wirelessly right from your Garmin device.

    This Specialized Turbo LEVO data field is a great example of the power that Connect IQ bring by connecting devices for a complete experience using the ANT technology.

    Read More

    Announcing Garmin vívoactive HR

    02/18/16 @ 04:44 PM

    The Next Great Connect IQ Watch

    vivoactive HR


    Mystery “Tall Watch” Revealed

    Back in January, we added the “Tall Watch” to the Connect IQ™ SDK, giving you the tools to develop for one of our most important device launches this year. Now it’s time to reveal the new vívoactive® HR — the ultra-thin fitness wearable evolved from our already successful vívoactive watch.


    This new GPS smartwatch — with built-in sports apps for running, cycling, SUP, skiing/snowboarding, golfing, swimming and more — is your all-day, everyday partner in fitness. It combines Elevate™ wrist heart rate technology with smart notification features, activity tracking and wireless connectivity that enables automatic uploads to Garmin Connect™. Plus, with Connect IQ you can develop watch faces, apps and widgets for vívoactive HR users to easily customize the device.

    Key Developer Features of the vivoactive HR watch

    • The new high bar for CIQ developers! The watch is twice as fast as Vivoactive, and has twice the available memory for app and data field developers!
    • This device is loaded with sensors, including WHRM, accelerometer, barometer, and compass.
    • CIQ + amazing battery life + WHRM = The best watch for fitness apps on the market

    Read More

    Connect IQ And The Wearable World

    01/29/16 @ 08:56 AM

    Simian Army
    The Connect IQ Alpha Monkey gave a talk at 2015. In this talk he discusses the challenges in creating the Connect IQ platform.

    How To Make A Connect IQ Watch Face

    01/15/16 @ 07:50 AM

    Developer Petr Koula (maker of the very popular ActiFace watch face) has made a great YouTube tutorial on how to create a watch face using Connect IQ!

    Connect IQ at CES

    01/13/16 @ 06:03 PM

    Garmin at CES 2016

    Here is a video taste of Connect IQ at the Consumer Electronics Show this year.

    Read More

    CES 2016 and Connect IQ 1.2.2

    01/06/16 @ 10:51 AM

    All of us here on the Connect IQ team are ecstatic for 2016. We're eager to share with you what we've been working on the last several months, so let's get right to it!

    New Year, New SDK

    Edge and Fenix 3 IQ Logo

    Today we're launching version 1.2.2 of the Connect IQ SDK. This SDK has multiple key updates, including the following:

    • Edge data fields can now be uploaded to the store.
    • fēnix 3 HR and tactix Bravo devices are now supported in the Connect IQ SDK.
    • There's a new screen size called “Tall Watch” for you to explore. (Sounds fun, right?)

    Read More

    Connect IQ 1.2 and Three New Devices

    11/05/15 @ 05:44 AM

    Today is a big day where a lot of key components come together for the next wave of Connect IQ features.

    First, Connect IQ 1.2 is now in production so your amazing apps that leverage the new features in Connect IQ 1.2 can now be downloaded to a device. We have 3 new Connect IQ watches with the new Forerunner family of watches. We also have a brand new redesigned Garmin Connect Mobile application.

    Let’s start with Connect IQ 1.2…

    Read More

    Connect IQ now on the EDGE

    09/29/15 @ 10:52 AM

    When will Connect IQ be on the Edge???

    This is the question we get the most from our developer community and passionate people who love Garmin devices.

    We listened…

    Edge and Connect IQ

    Read More

    Announcing Connect IQ 1.2

    09/29/15 @ 09:59 AM

    One year ago, we opened up a world of possibility when we launched Connect IQ for Garmin devices. That was an exciting milestone for us and for you, our developers.

    Today, we’re thrilled to announce another huge milestone: Connect IQ 1.2.


    Read More

    The New Badge and Other Updates

    08/22/15 @ 08:32 AM

    New Badge

    Just wanted to let you know about a couple updates we have recently added to the Connect IQ Store.

    1. New Badge - New apps will now have a New Badge for the first 14 days they are in the store.  We added this to give more visibility to the new apps in the store as a user browses around.  This badge will be shown on both the lists and detail page views. 
    2. Minimum SDK check - We are continuously working to provide new features and improvements to the developer tools available in the SDK.  To make sure uploaded apps have the latest and greatest version of the SDK we have added an SDK Version check to the process.  This will make sure that your app is able to take advantage of these improvements.

    If you have questions on either of these please post them to the forum.

    You know what else is amazing??  In June we announced that we reached the 1 Million downloads threshold, which was very exciting to us!  We continue to be amazed at the growth we are seeing in this platform because to get to 1 Million it took about 6 months but over July there were already 600,000 more downloads!  Amazing! 

    This is a testament to the value and innovation that you our developer community is bringing to this platform. 

    Thank you for all you do and we look forward to seeing what’s next!

    The Connect IQ Team


    Connect IQ Store Updates - New Apps and Developer Metrics

    07/15/15 @ 10:45 AM

    Today, we are launching two new features in the Connect IQ app store that will directly benefit both our developers and Connect IQ users!

      New and Updated Apps: This new section will have the newest and latest apps on the store.  Users will be able to find these new and updated apps on both the Connect IQ Store home page and as a section on the device pages (ex. fenix 3). This should make it much easier for people to find the latest and greatest apps in the store!
      Developer Statistics: Developers will now be able to see downloads graphed across the past 10 days, weeks, and months. When logged into the store you should have it available next to your reviews.  This should provide you with a much better view into how your app is performing.

    These new features in the store are just some of the ways we are always looking to improve the developer and users experience around Connect IQ.  We hope you like them.

    o/\o The Connect IQ Team

    Watch Faces a Favorite Among Our Users

    07/09/15 @ 08:30 AM

    We now have over 300 watches faces in the Connect IQ store and they have been downloaded over 550,000 times!! These watch faces have become a favorite among the Connect IQ devices owners as you can see on Instagram #ConnectIQ


    Watch Face: ActiFace Blue

    Far and above the favorite watch so far has been the ActiFace Blue from Koulik downloaded close to 50,000 times.

    Connect IQ watch faces are always on and visible, that way these watches always look like watches on your wrist even in the bright sunlight. Other smart watches turn the face off when not in use leaving them looking like a lifeless devices strapped to your wrist. This is a big differentiator for our watches because even with them on all the time users still get the weeks of battery life they love and expect from Garmin devices.

    Do you have an idea for a watch face?

    Here are some great resources...

    Read More


    06/26/15 @ 04:49 PM

    1000000 Connect IQ Downloads

    Thank You, Thank You, Thank You

    We are excited to announce that there have been over 1 million downloads of Connect IQ apps!! We cannot believe how fast we have gotten to this milestone and would not be here without you, our Connect IQ developer community. You are cranking out incredible apps for these Garmin devices, and our users love it, as you can see posts like these #ConnectIQ.

    We’re just getting started with Connect IQ. As Connect IQ devices enable more and more active lifestyles, your apps will continue to give these users amazing ways to customize their devices to fit their specific lifestyles. 

    Thank you, thank you, thank you, and congrats for your help in making the Connect IQ platform such a success. 

    High five from Connect IQ Team!


    App Migration

    06/19/15 @ 04:16 PM

    Our goal with Connect IQ™ is to make it easy for developers to target multiple Garmin devices, and at the same time give developers the choice of not supporting a product they don’t want to. The goal is to give us the flexibility to create purpose driven products, where we may make changes for the use case, while not requiring our developers to adapt to every one of these changes. There are a number of challenges with this system. For example, what if we create a product like the D2™ Bravo, which from the Connect IQ perspective is exactly the same as the fēnix® 3? We can’t tell developers about the product before launch, but developers will have to manually rebuild and re-upload their apps to the app store to add support for it. Assuming it takes 10 minutes and a 16 oz. soda to generate an app update, updating all the fēnix® 3 apps would require two and a half days and 66240 calories to move all the apps to D2™ Bravo. That would require a lot of steps to burn off.

    Read More

    Looking Forward: Connect IQ Release Schedule

    06/16/15 @ 04:28 PM

    Here at Monkey C headquarters, we love to give our developers candy. Candy, candy, candy! We wish we could give everyone candy every day, but sadly it takes us time to make the candy. It also takes us time to make sure the candy doesn’t leave a bad taste. The best way to make sure the candy we give you is delicious is to be open about when we are sending the candy, and what you can expect. [Editors Note: Garmin is a health and wellness company and would like to say that the Connect IQ team provides “Refreshing, healthy, low calorie vegetable smoothies” to its developers, not candy as previously inferred.]

    Read More

    Disc IQ: The Connect IQ Disc Golf App

    05/12/15 @ 10:19 AM

    Our team was interested in seeing how we could combine some APIs together to push the boundaries of the SDK. With the single instruction of “make a watch app that uses a companion app” from our fearless Alpha Monkey we decided to set out writing a disc golf sample.

    The basic idea was to use an Android app to create a course on a phone, send it to the watch via the Connect IQ companion SDK, score the course on the watch and then send the completed scorecard back to the phone. This would provide us a great way to get a more comprehensive look at the SDK and, of course, document what we found useful along the way. Without further ado, here are some of the key findings we made.

    Read More

    Writing a Wearable Web Service

    04/09/15 @ 03:43 PM

    The Connect IQ Communication API is the API that brings the wearable web to Garmin devices. However, there are some subtleties to how to expose a web service to a Garmin device.

    Read More

    Apps and widgets now available!

    03/06/15 @ 04:22 PM

    It has been almost six months since we announced Connect IQ, and we are excited about what this platform and the Connect IQ community has become. 

    Today we’re launching the next major piece: widgets and apps in the Connect IQ Store

    You will see a few apps by Garmin there, but the power of Connect IQ comes from what you create.

    Read More

    A Look Back at CES 2015

    01/16/15 @ 04:43 PM

    Now that the dust has settled a little bit since CES we wanted to share some of the exciting coverage we got around the new Connect IQ compatible products and the Connect IQ platform.

    Read More

    These 7 Connect IQ Partners Will Inspire You

    01/05/15 @ 02:23 PM

    In conjunction with the launch of new products at CES, we’re super excited to partner with companies that each show valuable new use cases for our wearable devices. The apps from these partners take the Connect IQ platform to new and exciting places.

    Read More

    Connect IQ SDK Has Reached 1.0.0

    01/05/15 @ 02:16 PM

    Today, we’re launching the official version of the Connect IQ SDK. It’s no longer a preview, ladies and gentlemen. It’s Connect IQ 1.0.0 Aikido Monkey. Here’s what’s new in this version:

    • Simulators and device support for new compatible devices.
    • Access to device settings, such as time format (12-hour vs. 24-hour) and metric vs. statute.
    • Support for gestured watch faces. Previously, watch faces had been limited to updating once a minute. Now, watch faces can enable timers when you gesture that you’re looking at the watch.
    • Ability to generate apps for the Connect IQ Store using the Package tool.

    If you’re using the first or second preview SDKs, you’ll definitely want to update to version 1.0.0. And don’t forget you can now upload your watch faces and data fields to the Connect IQ Store.

    3 Amazing New Connect IQ Devices Will Bring Your Apps To Life

    01/05/15 @ 09:17 AM

    We’re launching 3 new compatible Connect IQ devices today at the Consumer Electronics Show in Las Vegas.

    Read More

    Ready to upload your creations to the Connect IQ Store?

    01/05/15 @ 09:02 AM

    We’ve been working on it for months, and now it’s (halfway) ready. The Connect IQ Store at is finally open for widgets and data fields. That means that users can now get all the wonderful widgets and data fields that you’ve built.

    Read More