The Tango project will be deprecated on March 1st, 2018.
Google is continuing AR development with ARCore, a new platform designed for building augmented reality apps for a broad range of devices without the requirement for specialized hardware.

In addition to working with our OEM partners on new devices, Google is also working closely with Asus, as one of our early Tango partners, to ensure that ZenFone AR will work with ARCore. We'll be back with more information soon on how existing and new ZenFone AR users will get access to ARCore apps.

Tango SDK Release Notes

Beginning with Hopak, the Tango SDK for Unity now releases on a separate schedule and we've moved the release notes to their own page.

June 2017: Ikariotikos

TangoSupport API

  • Added a Marker Detection Java sample.
  • Removed dependency of tango_client_api from tango_support_api. This change is to support the Tango pure Java path development.
    • TangoSupport C SDK: removed TangoSupport_initializeLibrary(void). Developers should use TangoSupport_initialize(TangoService_getPoseAtTime, TangoService_getCameraIntrinsics) to initialize.
    • TangoSupport Java SDK: changed TangoSupport.initialize() to TangoSupport.initialize(Tango tango).

Tango 3DR API


  • Fixed a bug where passing a NULL value for Tango3DR_ProgressCallback would result in crashes.

Bounding boxes API

Added an interface to query bounding boxes of Grid Segments and Mesh Segments:

  • Retrieves two position vectors that define the axis-aligned bounding box of a grid cell. Dimensions are in meters. Adjacent bounding boxes do not overlap and do not have space between them.

      Tango3DR_Status Tango3DR_getGridSegmentBoundingBox(
         const Tango3DR_ReconstructionContext context,
         const Tango3DR_GridIndex grid_index,
         Tango3DR_Vector3* corner_min,
         Tango3DR_Vector3* corner_max);
  • Retrieves positions of two corners that define location and shape of a mesh segment. Dimensions are in meters. Note that this is not necessarily the minimum bounding box, but the upper bound of mesh segment vertex positions. Adjacent bounding boxes do not overlap and do not have space between them.

      Tango3DR_Status Tango3DR_getMeshSegmentBoundingBox(
         const Tango3DR_ReconstructionContext context,
         const Tango3DR_GridIndex grid_index,
         Tango3DR_Vector3* corner_min,
         Tango3DR_Vector3* corner_max);

Reconstruction API

  • Renamed:
    • Tango3DR_setDepthCalibration -> Tango3DR_ReconstructionContext_setDepthCalibration
    • Tango3DR_setColorCalibration -> Tango3DR_ReconstructionContext_setColorCalibration

Floorplan API

  • When extracting a mesh while use_floorplan is enabled, the library now returns the normal 3D mesh. Previously, it returned an extruded mesh of the floorplan.
  • Added functions to extract raw SDF (signed distance function) images of the floor plan layers:

    // Note that the returned image has (x: right, y: down)
    void ExtractSdfSegment(const tsdf2::GridIndex& volume_index,
                             LayerType layer_index, engine_data::Image2* image);
    // Note that the returned image has (x: right, y: down).
    // The returned origin has (x: right, y: up).
    void ExtractFullSdf(LayerType layer_index, Eigen::Vector2f* origin,
                          engine_data::Image2* image);

Texturing API

  • The following functions to get/set runtime parameters have been removed:

     Tango3DR_Status Tango3DR_setRuntimeBool(Tango3DR_ReconstructionContext context,
                                             const char* key, bool value)
     Tango3DR_Status Tango3DR_getRuntimeBool(Tango3DR_ReconstructionContext context)
  • Modified the interface for loading color calibration into a Texturing Context. The calibration is no longer loaded from a dataset when the context is created.

    // Removed
    Tango3DR_TexturingContext Tango3DR_TexturingContext_create(
         const Tango3DR_Config texture_config, const char* const dataset_path,
         const Tango3DR_Mesh* tango_mesh);
    // Added
    Tango3DR_TexturingContext Tango3DR_TexturingContext_create(
         const Tango3DR_Config texture_config, const Tango3DR_Mesh* tango_mesh);

    Instead, the user must set it explicitly before using the context:`

    // Added
    Tango3DR_Status Tango3DR_TexturingContext_setColorCalibration(
        const Tango3DR_TexturingContext context,
        const Tango3DR_CameraCalibration* calibration);

    The calibration can be queried from the Tango API, or loaded from a dataset using the utility function:`

    Tango3DR_Status Tango3DR_CameraCalibration_loadFromDataset(
        Tango3DR_CameraId camera_id, const char* const dataset_path,
        Tango3DR_CameraCalibration* calibration);`

File IO for images and point clouds

  • Added functions to save and load clouds point to PLY files.

    Tango3DR_Status Tango3DR_PointCloud_saveToPly(const Tango3DR_PointCloud* cloud,
                                                  const char* const path);
    Tango3DR_Status Tango3DR_PointCloud_loadFromPly(const char* const path,
                                                    Tango3DR_PointCloud* cloud);
  • Added functions to save and load images to PNM and PNG files files.

    Tango3DR_Status Tango3DR_ImageBuffer_saveToPnm(
         const Tango3DR_ImageBuffer* image, const char* const path);
    Tango3DR_Status Tango3DR_ImageBuffer_saveToPng(
         const Tango3DR_ImageBuffer* image, const char* const path);
    Tango3DR_Status Tango3DR_ImageBuffer_loadFromPnm(const char* const path,
                                                     Tango3DR_ImageBuffer* image);
    Tango3DR_Status Tango3DR_ImageBuffer_loadFromPng(const char* const path,
                                                     Tango3DR_ImageBuffer* image);

Support for depth images:

  • Added a depth image type
  • Added a function to convert point clouds to depth images

    Tango3DR_Status Tango3DR_PointCloudToRectifiedDepthImage(
        const Tango3DR_PointCloud* cloud,
        const Tango3DR_CameraCalibration* depth_camera_calibration,
        Tango3DR_ImageBuffer* image);

Adding ADF functionality

This functionality was added in H, but was not included in the release notes.

  • Added new AreaDescription struct and functionality:

    typedef struct _Tango3DR_AreaDescription* Tango3DR_AreaDescription;
    Tango3DR_Status Tango3DR_AreaDescription_createFromDataset(
        const char* dataset_path, const char* loop_closure_database_path,
        Tango3DR_AreaDescription* area_description,
        Tango3DR_ProgressCallback progress_callback, void* callback_param);
    Tango3DR_Status Tango3DR_AreaDescription_destroy(
        Tango3DR_AreaDescription area_description);
    Tango3DR_Status Tango3DR_AreaDescription_saveToAdf(
        Tango3DR_AreaDescription area_description, const char* const path);
    Tango3DR_Status Tango3DR_AreaDescription_loadFromAdf(
        const char* const path, Tango3DR_AreaDescription* area_description);
    Tango3DR_Status Tango3DR_Trajectory_createFromAreaDescription(
        const Tango3DR_AreaDescription area_description,
        Tango3DR_Trajectory* trajectory);
    Tango3DR_Status Tango3DR_Trajectory_destroy(Tango3DR_Trajectory trajectory);
    Tango3DR_Status Tango3DR_getPoseAtTime(
        const Tango3DR_Trajectory trajectory,
        const double timestamp,
        Tango3DR_Pose* tango_pose);
  • Removed the Tango3DR_createTrajectoryFromDataset function. The functionality is now available by calling Tango3DR_AreaDescription_createFromDataset and Tango3DR_Trajectory_createFromAreaDescription in conjunction.

May 2017: Hopak

Marker Detection API

A new API is introduced in TangoSupport SDK to provide marker detection functionality. The API is able to detect single or multiple markers within an input image buffer. The marker can be either a QR code or an AR tag. For each of the markers, corners and poses of the marker are detected. This API is available in C SDK, Java SDK and Unity plugin.

Setting up and updating callbacks from Tango service

Sample Apps

  • Java and C sample app no longer support x86.
  • Added a new cpp app (cpp_marker_detection_example) to demonstrate the marker detection API.

Major Bug Fixes

  • Improved error-handling and lifecycle when rapidly switching between apps.
  • Improved RGB camera performance for the Lenovo Phab 2 Pro, fixing regressions introduced in Gankino.

3D Reconstruction API


  • Changed type of all void* handles to struct* for better type safety.
  • Renamed multiple functions and configs for better consistency:
    • Tango3DR_ContextTango3DR_ReconstructionContext
    • Tango3DR_ConfiHTango3DR_Config
    • Tango3DR_createTango3DR_ReconstructionContext_create
    • Tango3DR_destroyTango3DR_ReconstructionContext_destroy
    • Tango3DR_createTexturingContextTango3DR_TexturingContext_create
    • Tango3DR_destroyTexturingContextTango3DR_TexturingContext_destroy
    • TangoDataset_extractRawDataFromDatasetTango3DR_extractRawDataFromDataset
  • Simplified init/destroy interface for multiple structures, including Tango3DR_ImageBuffer, Tango3DR_Mesh, Tango3DR_PointCloud, Tango3DR_GridIndexArray, Tango3DR_FloorplanLevelArray, Tango3DR_PolygonArray Examples:

     // Removed:
     Tango3DR_PointCloud* Tango3DR_PointCloud_create(
         const uint32_t num_points);
     Tango3DR_Status Tango3DR_PointCloud_createEmpty(
         Tango3DR_PointCloud* cloud);
     // Added:
     Tango3DR_Status Tango3DR_PointCloud_init(
        const uint32_t num_points, Tango3DR_PointCloud* cloud);
     Tango3DR_Status Tango3DR_PointCloud_initEmpty(
        Tango3DR_PointCloud* cloud);
  • Some functions where the user needed to pass in a double pointer are simplified. Examples:

      // Removed:
      Tango3DR_Status Tango3DR_extractMeshSegment(
          const Tango3DR_ReconstructionContext context,
          const Tango3DR_GridIndex grid_index, Tango3DR_Mesh** mesh);
      // Added:
      Tango3DR_Status Tango3DR_extractMeshSegment(
          const Tango3DR_ReconstructionContext context,
          const Tango3DR_GridIndex grid_index, Tango3DR_Mesh* mesh);


  • Fixed a bug that occurred when initializing a Tango3DR_TexturingContext using a default Tango3DR_ConfigH.
  • Fixed a bug where the wrong pose was used in calls to Tango3DR_updateTexture and Tango3DR_updateTextureGl. The API now correctly interprets the pose as the image pose, as the documentation suggests.
  • Tango3DR_update and Tango3DR_updateTexture now support the RGB and RGBA image format (TANGO_3DR_HAL_PIXEL_FORMAT_YCrCb_420_SP, TANGO_3DR_HAL_PIXEL_FORMAT_RGB_888, TANGO_3DR_HAL_PIXEL_FORMAT_RGBA_8888) , in addition to YUV. Removed TANGO_3DR_HAL_PIXEL_FORMAT_YCrCb_420_SP.
  • Fixed a bug so that the texturing parameter max_num_textures actually limits the number of created texture images (in combination with the min_resolution parameter).

April 2017: Gankino

Image API

A change in Android N has mandated that the image planes of planar YUV images be padded to a certain size. The data structure which we provide to apps as part of our API, TangoImageBuffer, has no way to indicate to apps that there is now padding in the data where there wasn’t before.

To prevent apps from breaking, this API on Android N now copies the image into an intermediate buffer without the padding. This has a negative impact on performance, thermals and power consumption.

To help mitigate this, we’ve introduced a new API, TangoService_connectOnImageAvailable with a data structureTangoImage that contains separate pointers to the start of each plane in the image, along with plane specific data like plane size, row stride and pixel stride. Apps which switch to this new API won’t incur the performance penalty now associated with the old API on Android N devices.

The API has been fully backported to Android M, so it’s possible to switch to the new API even if you don’t have an Android N device yet.

Multithreaded rendering

The C API now supports getting the latest camera image's timestamp outside a GL thread. Previously you had to call TangoService_updateTextureExternalOes inside the GL thread, whereas now you can call TangoService_lockCameraBuffer in any thread, and pass the TangoBufferId to TangoService_updateTextureExternalOesForBuffer and TangoService_unlockCameraBuffer inside a GL thread.

Unity multithreaded rendering support will get added in a future release.

SDK updates

  • The Tango Unity SDK now has a single TangoCamera prefab that supports the TangoARCamera and TangoDeltaCamera use cases.
  • The TangoSupport_getPoseAtTime engine parameter split into two parameters: base_engine and target_engine.
  • Added TangoSupport_fitMultiplePlaneModelsNearPoint, which fits and returns multiple planes, if found, instead of just one, and updated cpp_plane_fitting_example to display this capability.

March 2017: Farandole

UX Framework (deprecated)

In order to reduce the complexity of the SDK and give developers more control, we are replacing the predefined behavior of the Java UX Framework with callbacks in the Support Library. It supports a similar set of sensor events and callbacks, but without the UI. For more information, see our updated UX overview and the documentation for the Support Library UX functions.

3D Reconstruction API

Added a new mesh texturing backend implemented in OpenGL which is faster but lower quality than the default CPU pipeline. You can define the backend to use as part of TANGO_3DR_CONFIG_TEXTURING.

February 2017: Eisa


Point cloud changes

To support upcoming changes in Android N, we made a few improvements to how our depth APIs work under the hood. These changes improve performance and ensure that your apps will continue to run smoothly across all supported Android platforms.

Unfortunately, this change is not compatible with some Java apps compiled with older versions of Tango. If your app is using the Java APIs with depth, you must recompile your app with the latest Tango SDK and push an update to Play Store. Recompiling may require some code changes, given the Java callback changes (see below) and earlier deprecation of XYZij in favor of XYZC.

The minimum version of Tango Core for Java has been updated to require the E-release or newer to accommodate this change. Running an updated Java app but an older version of Tango Core will trigger an out-of-date exception.

Apps using other platforms (C, Unity, Unreal), are not impacted and no action is required.

Java callback changes

We are simplifying the Tango callbacks in the Java API. The OnTangoUpdateListener interface is changing to an abstract class TangoUpdateCallback. These changes mean you only need to implement callbacks for the functions you use, and allow us to easily make non-breaking additions in the future. Existing apps will continue to function.

For example, this code:


mTango.connectListener(framePairs, new OnTangoUpdateListener() {

    public void onPoseAvailable(TangoPoseData pose) {
        pose; // This app only uses motion tracking

    public void onXyzIjAvailable(TangoXyzIjData xyzIj) {
        // We are not using onXyzIjAvailable for this app.

    public void onPointCloudAvailable(TangoPointCloudData xyzij) {
        // We are not using onPointCloudAvailable for this app.

    public void onTangoEvent(final TangoEvent event) {
        // Ignoring TangoEvents.

    public void onFrameAvailable(int cameraId) {
        // We are not using onFrameAvailable for this application.

can be changed to:


mTango.connectListener(framePairs, new TangoUpdateCallback() {
    public void onPoseAvailable(TangoPoseData pose) {
        // This app only needs MotionTracking, dealing with Pose data...

For classes that implemented OnTangoUpdateListener, for example:

public class ExampleClass implements Tango.OnTangoUpdateListener {

change to extending TangoUpdateCallback

public class ExampleClass extends Tango.TangoUpdateCallback {

Unity SDK:

  • Changed Tango3DRExtractWholeMesh to always get entire mesh in one call. The method signature has changed to accommodate this.
  • The TangoPointCloud prefab now exposes the depth timestamp field and added depth estimation method.

Tango Support Library

  • The getPoseAtTime and getMatrixAtTime functions now expect the display_rotation parameter to be the display rotation between the default and current orientation, not the display to camera rotation as it was before. Existing applications that use these functions will need to update their code after updating the support library.
  • [C, Java] Automatic display rotation support added to fitPlaneModelNearPoint, getDepthAtPointNearestNeighbor, getDepthAtPointBilateral, and findEdgesNearPoint.
  • [C, Java] Added the functions getVideoOverlayUVBasedOnDisplayRotation and getCameraIntrinsicsBasedOnDisplayRotation.

Java Samples

  • The floor plan example has been updated to leverage the 3D reconstruction library.

3D Reconstruction

  • Added an option to specify a path to the loop closure database files.
  • Added an option to export raw data from a dataset.
  • Fixed typo in parameter name (simplication -> simplification)
  • Added the Floorplan API in Java.

January 2017: Caporales

3D Reconstruction

  • Improved the quality of the reconstructed meshes when the resolution is changed from the default 3cm.

Mesh texturing using images

There is a new function for texturing a mesh from a sequence of input images with corresponding poses. This workflow is targeting offline use.

There is a texturing context as well as utility functions to create and destroy it:

typedef void* Tango3DR_TexturingContext;

Tango3DR_TexturingContext Tango3DR_createTexturingContext(
    const Tango3DR_ConfigH texture_config, const char* const dataset_path,
    const Tango3DR_Mesh* tango_mesh);

The texturing context is used to texture a specific mesh from a sequence of input images with given poses. To apply a texture from images, call the update function on the context:

Tango3DR_Status Tango3DR_updateTexture(Tango3DR_TexturingContext context,
                                       const Tango3DR_ImageBuffer* image,
                                       const Tango3DR_Pose* image_pose);

To get the pose of the image, use the new utility function to get a pose from a Tango trajectory:

Tango3DR_Status Tango3DR_getPoseAtTime(const Tango3DR_TrajectoryH trajectory,
                                       const double timestamp,
                                       Tango3DR_Pose* tango_pose);

After calling update for all the images, get the textured mesh by calling:

Tango3DR_Status Tango3DR_getTexturedMesh(
    const Tango3DR_TexturingContext context, Tango3DR_Mesh** tango_mesh_out);

Finally, clean up by destroying the context:

Tango3DR_Status Tango3DR_destroyTexturingContext(
    Tango3DR_TexturingContext context);

2D floor plan extraction

The API now includes functions for 2D floor plan extraction. These functions are built on top of the 3D Reconstruction API and target both online and offline use.

  • To enable floor plan mapping mode, set use_floorplan to true in TANGO_3DR_CONFIG_CONTEXT.
  • Before extracting a 3D mesh or a 2D floor plan, call Tango3DR_updateFloorplan / Tango3DR_updateFullFloorplan to update the internal floor plan representation.
  • When you call any of the Tango3DR_extractMesh functions, you get an extruded 3D mesh of the floor plan.
  • To get a vectorized 2D version of the floor plan, call Tango3DR_extractFullFloorplan / Tango3DR_extractFloorplanSegment, which returns a freshly allocated Tango3DR_VectorGraphics object.
  • Finally, call Tango3DR_VectorGraphics_destroy to free the memory of the vector graphics object.

Tango Support Library

  • [C, Java] fitPlaneModelNearPoint, getDepthAtPointNearestNeighbor, getDepthAtPointBilateral, and [C] findEdgesNearPoint now accept transformations (as a translation/orientation pair) from the point cloud and/or color camera frame of reference to a user-specified frame.

Unity SDK

  • Changed OnUxExceptionEventHandler to be executed on Unity's main thread.
  • Added a ITangoUXMultithreaded interface to allow multi-threaded UX events.

December 2016: Biyelgee


  • The Tango API now correctly supports the “5 Parameter Polynomial” camera calibration model.

Support Library

November 2016: Argentine Tango


  • Added interface to request Android permissions through the Unity SDK.
  • TangoManager.RequestPermissions() now requests Android camera permission if necessary.
  • The UX support library has been localized to various languages.
  • Added a Keep Awake checkbox to the Tango Application prefab which prevents the screen from turning off.


  • [Java] Samples now correctly handle auto rotation on all devices.
  • [Java] New Occlusion example released.

November 2016: Zaniah


  • Reorganized AAR files in Unity into a single unity_plugin_merged.aar. This may cause compatibility issues with some plugins and will be fixed with the next release.

October 2016: Yildun


  • TangoXYZij and Experimental Video Overlay AR support has been removed.


  • [C] Added an experiment using Tango pose data for video stabilization.
  • [Java] Added an experiment using Tango depth data for "green screen" background separation.

September 2016: Wasat


  • The feature detection system has been improved. This should increase system stability and improve performance for motion tracking and area learning. The changes are backwards compatible with existing ADFs.


  • The Unity SDK now supports IL2CPP.

Support Library

  • [C] Added corner detection functions to the support library.

September 2016: Vega


  • Java now supports TangoPointCloud.

Support Library

  • The support libraries now use TangoPointCloud.
  • [C, Java] Support library functions no longer need camera intrinsics passed in.
  • [C, Java] The fitPlaneModelNearClick function has been renamed to fitPlaneModelNearPoint.

August 2016: Unukalhai

Known issues

If you are a longtime user of the development kit and are having issues saving or reading ADFs, go to Settings > Apps > [Project] Tango Core and uninstall updates, then reinstall the latest version from the Play Store.


  • Unity 5.4 is now supported.
  • The Unity SDK has been migrated to use Tango Point Cloud.

Support Library

  • [C] Tango Point Cloud is now supported.

August 2016: Tania Borealis


  • You can now query for the exposure time of a TangoImageBuffer.


  • The AR screen prefab and scripts have changed to use the GL_TEXTURE_EXTERNAL_OES GL extension, which is up to 4 ms faster than the previous implementation. It also eliminates camera issues related to app suspend and resume. The previous YUV texture is now deprecated.
  • Unity now includes an option for Environmental Lighting, which causes the real-world lighting conditions to impact how virtual objects are rendered in AR. For more information, see our blog post.
  • Options to adjust screen resolution have been added to the Tango Application prefab. See the flags for adjustScreenResolution and targetResolution for more information.
  • The OnDisplayChanged callback has been added to help you detect and handle screen rotations.

Support Library

  • The previously-deprecated function getPoseInEngineFrame has been removed. Its functionality is available through TangoSupport_getPoseAtTime.

July 2016: Qianru

The Qianru release includes a mandatory OTA update.


The TangoService namespace was updated to To use the new namespace, update your Tango libraries/SDK to the latest version and recompile your application. This change does not require modifications to application code in most cases. The Tango Development Kit tablet is backwards compatible with the original namespace, but consumer devices like the Lenovo Phab 2 Pro will only support apps using the new namespace and the previous changeover to libtango_device2.


In order to improve the performance of the Tango platform on Unity, we are changing the minimum version to 5.2, the earliest version which supports these optimizations. In the near future we will no longer distribute a version of the SDK for Unity 4, and all samples will be updated to Unity 5.2.

3D Reconstruction

June 6, 2016: Okul


  • A regression causing the color camera texture to be incorrect in some cases has been fixed.


Experimental Tango emulation is available in the Unity editor

While in Play mode, you can emulate movement and depth data, allowing you to test your application without building an APK and running on a device every time.

Motion tracking movement can be emulated in Play mode with WASD and mouse look. Because the mouse has only two axes, it only emulates yaw and pitch with the X and Y axes respectively. Roll is emulated by holding left-Shift and moving the mouse along the X axis. To move the mouse without rotating the camera, hold down left-Alt (left-Cmd on Mac).

Depth sensing is emulated by setting a mesh on the Tango Application in the Inspector. Sensor error is not emulated, you always get perfectly accurate points. Depth Sensing emulation can have a significant performance impact so you can disable Depth Sensing in the Inspector if necessary.

Video overlay is emulated in the same way as Depth Sensing. The mesh can optionally have vertex colors (like from Constructor). Additionally, you can add a single directional light to the video overlay emulation in case the mesh does not have any vertex colors. Video overlay emulation currently has significant impact on performance in Windows.

Other changes include:

  • OpenGL ES 3.0 compatibility. The VideoOverlay render pipeline is now compatible with OpenGL ES 3.0.
  • TangoPointCloudFinder has been added to easily set game objects to real-world floor height.

Support Library

  • The functions getPoseInEngineFrame and getWorldTCameraPose are deprecated and will be removed in a future release. Their functionality is available through TangoSupport_getPoseAtTime.


    // Implementation using getWorldTCameraPose
    // pose_start_service_T_device is TangoPoseData containing a pose for device with respect
    // to start of service and TangoSupport_getWorldTCameraPose converts to pose in OpenGl
    // coordinate frame
    double position[3];
    double orientation[4];
    TangoErrorType result;
    result = TangoSupport_getWorldTCameraPose(TANGO_SUPPORT_COORDINATE_CONVENTION_OPENGL,
                                              position, orientation);
    if (result != TANGO_SUCCESS) {
      LOGE("Error in conversion to OpenGl coordinate frame");
    // New implementation, using TangoSupport_getPoseAtTime
    // Get current pose for device with respect to start of service in OpenGl coordinate
    // frame using natural rotation for the device.
    TangoPoseData output_pose;
                               ROTATION_0, &output_pose);
    if (output_pose.status_code != TANGO_POSE_VALID) {
      LOGE("Unable to get valid pose for device with respect to start of service”);
    // output_pose.translation == position from getWorldTCameraPose
    // output_pose.orientation == orientation from getWorldTCameraPose


    // Implementation using getPoseInEngineFrame
    // pose_start_service_T_device is TangoPoseData containing a pose for device with respect
    // to start of service. TangoSupport_getPoseInEngineFrame calculates
    // pose of a selected Tango target coordinate frame (TANGO_COORDINATE_FRAME_CAMERA_DEPTH)
    // in the selected rendering engine world coordinate frame
    // coordinate frame
    TangoPoseData output_pose;
    TangoErrorType result;
    result = TangoSupport_getPoseInEngineFrame(TANGO_SUPPORT_COORDINATE_CONVENTION_OPENGL,
                                               pose_start_service_T_device, &output_pose);
    if (result != TANGO_SUCCESS) {
      LOGE("Error in calculation of pose of depth frame in OpenGl coordinate frame.");
    // New implementation, using TangoSupport_getPoseAtTime
    // Get current pose for depth frame with respect to start of service in OpenGl coordinate
    // frame using natural rotation for the device.
    TangoPoseData output_pose;
                               TANGO_SUPPORT_ENGINE_OPENGL, ROTATION_0, &output_pose);
    if (output_pose.status_code != TANGO_POSE_VALID) {
      LOGE("Unable to get valid pose for device with respect to start of service”);

May 9, 2016: Mira


  • Tango now runs as a normal Android Service instead of as a system service. You must migrate your app to use Tango as a service or it will not work on future devices. See the migration guide for details.

  • The 3D Reconstruction library is now distributed as a stand-alone library in C. See the reference page for more details, and visit the downloads page to get the files.


  • The struct APISignedDistanceVoxel has been renamed to SignedDistanceVoxel. This impacts the function Tango3DRExtractSignedDistanceVoxel.


  • All samples have been updated to use Tango as a standard Android service.

April 25, 2016: Lucida Anseris


  • The FindFloorPlane function has been added to the PointCloud prefab. This function attempts to automatically find the floor without user interaction.

Support Library

  • [C] Edge detection has been added to the support library. The function finds edges near the specified location on the same plane as the specified location. Edge detection uses the color camera image, with the depth data used to confirm the edge is on the same plane.


  • [Unity] The ExperimentalMeshOcclusion example has been added to the Unity SDK. This example uses the meshing interface to implement occlusion based on static objects in the real world. The mesh is aligned to an ADF which is created with the mesh and can be loaded together.

March 30, 2016: Kajam


  • [Java] Refactored the Java augmented reality sample to better separate Tango from the rendering engine code. Specifically, we have separated out the code to synchronize camera frames with pose updates based on timestamps, which is needed for well-registered augmented reality.

March 16, 2016: Jih

Support Library


  • [Unity] A new scene TangoCardboardWithMeshing has been added to TangoWithCardboardExperiments. The example uses 3D Reconstruction to display a mesh of your environment within Cardboard.

March 3, 2016: Izar


  • The Tango Hardware Abstraction Layer (HAL) has been released. Similar to the Android HAL, this is a layer that sits between the hardware and the APIs which allows Tango to be agnostic about the hardware a particular device uses. This also enables the same application to work similarly across all current and future Tango devices.
  • The area learning pipeline has been improved. The new pipeline is more robust and designed to make area descriptions more compatible between different devices.

These changes are backwards compatible, but your app may perform differently.

Unity SDK

  • 3D Reconstruction features have been released (experimental). The 3D Reconstruction options allow you to create 3D meshes of your environment using the depth camera of Tango. This version of meshing is built into the Tango Core, and performs much better than the previous Unity example of 3D meshing. There are two new examples, ExperimentalMeshBuilderWithColor and ExperimentalMeshBuilderWithPhysics, which show how to use the 3D Reconstruction features.
  • Deprecated methods in TangoPointCloud have been removed.

Support Library

  • [C] The function TangoSupport_GetTangoVersion has been added to the C Support Library.


  • The C and Java samples have been reorganized. The content is the same, but directories have been renamed to be more consistent.
  • [Unity] TangoWithMultiplayer has been added.
  • [Unity] TangoWithCardboardExperiments has been added. This sample shows how to combine the Tango SDK with the Cardboard Unity SDK to experiment with 6-DOF VR on Tango devices.
  • [Unity] ExperimentalMeshBuilderWithColor and ExperimentalMeshBuilderWithPhysics have been added to the SDK examples. These samples show how to use the new 3D Reconstruction features in the Unity SDK.
  • [C] cpp_point_cloud_example has been added, which allows a user to measure the distance between two points selected by the user in augmented reality.
  • [C] The motion tracking sample now supports screen rotation.
  • [Java] java_point_to_point_example has been added, which allows a user to measure the distance between two points selected by the user in augmented reality.
  • [Java] The motion tracking sample now supports screen rotation.

February 3, 2016: Gemma (Tango Core 1.31)

The Gemma release consists of software updates only, there is no associated OTA update.

Unity SDK

  • The names of the Area Description options in Tango Manager have changed. Instead of Load ADF and Area Learning, there is the option Enable Area Descriptions with a Learning Mode option under it. Existing applications will continue to work, but if you are using area descriptions and update the SDK, you will need to update your project to adjust.
  • The UI for handling video overlays has been changed. If Enable Video Overlay is selected, you'll see a drop-down menu to select the video overlay method. Selecting TextureID enables the OnExperimentalTangoImageAvailable callback of the IExperimentalTangoVideoOverlay interface. This provides the same functionality as the Experimental Video Overlay did before. Selecting Raw Bytes enables the OnTangoImageAvailableEventHandler callback of the ITangoVideoOverlay interface. This is the same behavior as having only Enable Video Overlay enabled before. You also have the option to enable both methods. If you are using the AR Camera prefab, the TextureID method or Both must be selected.

Support Library

January 20, 2016: Furud (Tango Core 1.30)

The Furud release consists of software updates only, there is no associated OTA update.

Support Library

  • Various functions now return TANGO_INVALID when passed invalid parameters, instead of killing the application.

Unity SDK

  • In an upcoming release, the names of the Area Description options in Tango Manager will change. Instead of "Load ADF" and "Area Learning", there will be an option "Enable Area Descriptions" with a "Learning Mode" option under it. Existing applications will continue to work, but if you are using area descriptions and update the SDK, you will need to update your project to adjust.
  • IsTangoCoreUpToDate() has been added to the AndroidHelper class.

Unity Samples

  • The new example sceneDetectTangoCore shows how to create an application that knows if it is on a Tango device, and whether Tango is up todate.

January 11, 2016: Electra (Tango Core 1.29)

Happy New Year! The Electra release consists of software updates only, there is no associated OTA update.

Java Samples Changes

  • The Java point cloud and AR samples have been updated to handle depth data copying and rendering in a thread-safe way. Specifically, they now use the Java Support Library's TangoPointCloudManager to prevent data access or rendering mid-update.
  • Java samples have been refactored to better separate application and rendering logic.

Support Library Changes

  • Depth upsampling functions have been added to C and Java. See the updated C and Java support tutorials for more information, as well as the C and Java API references for details.

UX Library Changes

  • If the Tango service fails to connect, the connection screen now goes away after 10 seconds and throws a UxExceptionEvent.TYPE_TANGO_SERVICE_NOT_RESPONDING exception. Before, the connection screen would remain up indefinitely.
  • When an out of date version of Tango Core is detected, the error screen now provides a link to the Play Store to get the update.

December 9, 2015: Capella (Tango Core 1.27)

The Capella release consists of software updates only, there is no associated OTA update.

Unity SDK Changes

  • The Unity SDK now has different versions for Unity 4 and Unity 5. The Unity 5 SDK now bundles the samples by default.
  • Autostart is now enabled by default.
  • Previously deprecated functions have been removed from the SDK.
  • The Unity AR sample now turns off depth when it is not used.

Support Library Changes

  • The Image Buffer Manager has been added to the C support library. This new feature provides a thread-safe triple buffer data structure to manage transferring image data (TangoImageData) from the callback thread to a render or computation thread.
  • The Point Cloud Manager has been added to the C and Java support libraries. This new feature provides a thread safe triple buffer data structure to manage transferring tango depth data (TangoXYZij) from the callback thread to a render or computation thread.
  • The Transformation Helper has been added to the C support library. This new feature provides helper utilities to convert Tango data into various common coordinate system conventions.

November 25, 2015: Bellatrix - Skipped

The Bellatrix release was skipped.

November 11, 2015: Ancha (Tango Core 1.26)

The Ancha release consists of software updates only, there is no associated OTA update.

General Changes

  • Motion Tracking no longer requires permission checks. If Motion Tracking permissions are requested, they are automatically granted. You should still remove permission checks for Motion Tracking from your code.

Unity SDK Changes


  • You should register lifecycle callbacks with the Register function. Rather than calling RegisterPermissionsCallback, RegisterOnTangoConnect, and RegisterOnTangoDisconnect, implement the ITangoLifecycle interface and call Register. The old registration functions are deprecated and scheduled for removal in a future release.
  • Simplified initialization of the TangoApplication:
    • RequestNecessaryPermissionsAndConnect is now RequestPermissions.
    • InitApplication, InitProviders, and ConnectToService have been grouped into one method: Startup that takes an optional Area Description to load.
    • The old initialization functions are deprecated and scheduled for removal in a future release.
  • Added an auto-connect option on TangoApplication. Enabling this option automatically calls Startup and RequestPermissions. In the next release, this will be on by default for prefabs and samples.
  • Added a Unity Area Learning code sample for Points of Interest.
  • Added a Unity Area Learning code sample for viewing ADF quality.

Other Announcements:

  • The next release removes the deprecated Unity Area Description API in favor of the new API released in Zeno. Please move to the new API in this release.
  • The next release will not support explicit calls to mouse emulation. Instead, pose updates will provide mouse emulation.

Support Library Changes

  • C - Added the TangoSupport_calculateRelativePose function to simplify transform computation between camera frames at different times.
  • Made a bug fix for compatibility issue with the Zeno version of the support library. The Zeno version of the library can only be used with the Zeno Tango Core. Future versions of the support library are compatible across Tango Core versions.

October 28, 2015: Zeno (Tango Core 1.25)

The Zeno release consists of software updates only, there is no associated OTA update.

General Changes

  • The Tango Support Library has been released for C, Java, and Unity. See the Support Library section below for more details.
  • config_color_mode_auto, config_color_iso and config_color_exp now work correctly.

Unity SDK Changes

The Unity Area Description API was refactored to be more organized. The new API is in the AreaDescription class. The old API in the PoseProvider class will be removed in a future release.

Area descriptions and the associated metadata are now normal C# classes with members for relevant data. The old classes are replaced with new ones as follows:

  • UUIDUnityHolder is now AreaDescription
  • UUID_list is now AreaDescription[]
  • Metadata is now AreaDescription.Metadata
  • UUID is deprecated

These are the important functions in the new API:

  • You no longer need to call PoseProvider.RefreshADFList() before getting a list of ADFs.
  • To get a list of area descriptions, call AreaDescription.GetList().
  • To get a specific area description, call AreaDescription.ForUUID().
  • If you are connected to the Tango Service in learning mode and want to save the current area description, call AreaDescription.SaveCurrent().

This example uses the new API to print out the UUIDs and names of the area descriptions on the device:

foreach (AreaDescription ad in AreaDescription.GetList())
    AreaDescription.Metadata metadata = ad.GetMetadata();
    Debug.Log("UUID=" + ad.m_uuid + ", Name=" + metadata.m_name);

// modify metadata
string uuid = ...;
AreaDescription ad = AreaDescription.ForUUID(uuid);
if (ad != null)
    AreaDescription.Metadata metadata = ad.GetMetadata();
    metadata.m_name = …;
    // You can modify other fields too.

Other updates:

  • The AR camera prefab now includes an occlusion checkbox, which uses the latest depth information to show rough occlusion.
  • The AR camera prefab now accounts for camera distortion.
  • The Tango Delta Camera prefab's clutch function now works correctly when using the Tango Point Cloud prefab.
  • The GitHub examples project now opens without errors.

Support Library Changes

  • The Tango Support Library has been released for C, Java, and Unity. The support libraries contain functions to help you manage and use data from the Tango APIs. For more information, see our pages for C, Java and Unity.
  • Most code samples which use depth have been updated to use the support library.

UX Framework Changes

  • Hold Posture Exceptions can now be set through the Tango Ux component of the Tango Manager prefab.

October 14, 2015: Yamabe (Tango Core 1.24)

The Yamabe release consists of software updates only, there is no associated OTA update.

Java API Changes

  • The code samples for Java have been refactored. The motion tracking, area learning, and point cloud samples now use Rajawali as the rendering library.

Unity SDK Changes

  • An Augmented Reality prefab has been added to the Unity SDK under Assets > TangoPrefabs, allowing you to properly implement AR in your app in a drag and drop way.
  • ADF export and import have been fixed.
  • The checkbox for high accuracy area learning has been removed from the Tango Manager prefab.
  • Code samples working with ADFs now handle save calls asynchronously.

UX Framework Changes

  • Hold Posture Exceptions have been added to Unity.

September 30, 2015: Xiaotong (Tango Core 1.23)

The Xiaotong release consists of software updates only, there is no associated OTA update.

Area Learning and ADF Changes

Area learning and ADFs are changing under the hood starting with the Xiaotong release. New ADFs now use a new algorithm which improves localization speed and accuracy. The API itself remains essentially the same, but there are a few important changes in behavior.

  • Calls to save an area description will run longer than before. For example, an ADF recorded over 3 minutes takes about 25 seconds to finish saving. As before, this call maintains a lock and will block other calls, so make sure not to use the UI thread.
  • Because save can take some time, we've added a new Tango Event with the progress of the save call. The type is EVENT_AREA_LEARNING, the key is KEY_AREA_DESCRIPTION_SAVE_PROGRESS, and the value is a floating point number from 0 to 1 encoded as a string. Your application should show some UI while the save is occurring, and show the user the current progress.
  • Saving an ADF now stops motion tracking and area learning. You must disconnect and reconnect to resume motion tracking or load the new ADF. After saving, you can optionally call getPoseAtTime with to get refined poses at timestamps earlier than the save call.
  • Extending an ADF (i.e. loading an ADF with learning mode on, localizing to the ADF, learning additional areas, and then calling save) will now create a new file with a new UUID. Previously, the loaded ADF was overwritten with the same UUID.
  • With these changes, the config_experimental_high_accuracy_small_scale_adf flag will have no effect and will be removed in a future release.
  • You can continue to load old ADFs, but you will not be able to extend them or convert them to the new version. Loading an old ADF with learning mode on will result in an error.

These changes impact all APIs. See the appropriate reference pages for more details.

Here's an example of the basic usage pattern:

// Start up Tango service.

// Walk around to learn the area.

// Create progress UI for the save operation, handle onTangoEvent.
onTangoEvent(TangoEvent event) {
  if (event.type == EVENT_AREA_LEARNING &&
    // Update progress UI using event.value.

// Save the new area description to disk from a background thread.
UUID* my_uuid

// Remove/hide progress UI.

// Shut down Tango service.

Unity SDK Changes

  • The framerate of the depth camera can now be adjusted at runtime, including turning it off entirely. For more information, see the Unity SDK reference on SetDepthCameraRate.

UX Framework Changes

  • The Java UX Framework API has changed significantly with this release. To upgrade, see our guide on the needed code changes.
  • A new exception type has been added to the Java UX Framework API which instructs users on the correct way to hold their device while using your application. For more information, see the documentation on Hold Posture Exceptions.

September 16, 2015: Weyl (Tango Core 1.22)

The Weyl release consists of software updates only, there is no associated OTA update.

Upcoming Changes

We work hard to minimize breaking changes to our APIs, but sometimes it is unavoidable. In those cases, we will let you know at least a release in advance to give you time to make any necessary changes.

  • We are changing the way ADFs work under the hood to improve speed and accuracy. The APIs will remain the same, but save calls will take significantly longer than before. Save calls should not be called from the UI thread. Instead, execute save calls in a background job. In addition, you will no longer receive new poses after the save call finishes.
  • The Java UX framework API will be changed significantly in a future release. These changes will not impact already-compiled applications, but if you update the UX framework you will need to change your implementation. We will provide a migration guide where necessary.

C API Changes

  • The framerate of the depth camera can now be adjusted at runtime, including turning it off entirely. For more information, see the C API reference on the config_runtime_depth_framerate configuration parameter and the new TangoService_setRuntimeConfig function.

Java API Changes

  • The framerate of the depth camera can now be adjusted at runtime, including turning it off entirely. For more information, see the Java API reference on the KEY_INT_RUNTIME_DEPTH_FRAMERATE constant of the TangoConfig class and the new setRuntimeConfig method of the Tango class.

Unity SDK Changes

  • The Unity SDK and public API is being cleaned and refactored. Some functions have been deprecated or made internal to the SDK. Developers using only the prefabs will be unaffected. If you have implemented custom functionality, check the Unity API reference where affected functions are noted in their comments. The changes will occur in a future update.

September 2, 2015: Von Mises (Tango Core 1.21)

The Von Mises release consists of software updates only, there is no associated OTA update.

Unity SDK Changes

  • The YUV to RGB shader for the color camera has been improved. Colors should render more accurately.
  • The Tango Manager prefab has been moved to the Assets > TangoPrefabs folder of the SDK.
  • A new Tango Delta Camera prefab has been added. It updates the position with deltas, so movement can be done using a CharacterController, physics, or anything else that wants deltas. The prefab also includes a "clutch" which temporarily disables motion tracking, allowing you to reposition yourself in the real world if you run out of room. The prefab is in the Assets > TangoPrefabs folder of the SDK.
  • Most of the example scenes have been updated to use the Tango Delta Camera prefab.

UX Framework Changes

  • The Connecting screen art has been updated.

August 19, 2015: Urquhart (Tango Core 1.20 / KOT49H.150811)

OTA / General Changes

  • The motion tracking algorithm has been updated. New ADFs created in Urquhart cannot be loaded by older versions of Tango Core, but older ADFs should continue to work.
  • Low latency poses (config_low_latency_imu_integration) is now turned on by default.

Unity SDK Changes

  • The TangoPointCloud prefab now has a method FindPlane(). Given a screen coordinate and search radius, it finds the plane that most closely fits depth the values in that area. See Assets/TangoPrefabs/Scripts/TangoPointCloud.cs for more information.
  • The Augmented Reality sample has been updated to use the FindPlane() method. See AugmentedRealityGUIController.cs for an example of how to use FindPlane().

UX Framework Changes

  • The Java and Unity UX Frameworks have been updated with bug fixes. Error detection for runtime version, Tango core version, lying on table, and depth have been improved.

August 8, 2015: Turing (Tango Core 1.19)

OTA / General Changes

  • Fixed an issue involving time stamp associations.
  • Added an option under Settings > Tango > Configuration Options to correct for banding effects on the cameras due to 50 Hz light.

C API Changes

  • The C sample code now includes rgb-depth-sync-example, an example of projecting the depth information into the color camera.

UX Framework Changes

  • The Java UX Framework has been updated to improve performance and simplify the development process. In preparation for future changes, the method disableMotionTracking() has been removed from TangoUx.Builder. If your application does not use motion tracking, you should disable the connection screen instead of calling the removed method. You can do this by calling mTangoUxLayout.getSettings().setConnectionLayoutEnabled(false); before calling mTangoUx.start();.

Unity SDK Changes

  • Removed the Low Latency Pose checkbox from the Tango Application script. This setting has been on by default, and should be used by all applications.

July 22, 2015: Schur (Tango Core 1.18)

The Schur release consists of software updates only, there is no associated OTA update.

Unity SDK Changes

  • The SDK has been refactored and the UX framework is now in a separate script. This has no impact for compiled applications. If you update the SDK in an existing application the UX framework settings will be reset to default values.
  • The SDK now includes a Tango Simple Camera prefab. See our tutorial for how to include it in your project.

July 8, 2015: Ramanujan (Tango Core 1.17)

The Ramanujan release consists of software updates only, there is no associated OTA update.

Java API Changes

  • In the Java API, the init method of TangoTextureCameraPreview is now correctly set to private. If you were using the init method in your code your application will no longer work.
  • The UX Framework library has been released and is available from the downloads page.

Unity SDK Changes

  • The Unity code samples structure has changed. Instead of multiple projects, there is now one project containing each example as a separate scene.

June 24, 2015: Quine (Tango Core 1.16)

The Quine release consists of software updates only, there is no associated OTA update.

Upcoming Changes

We work hard to minimize breaking changes to our APIs, but sometimes it is unavoidable. In those cases, we will let you know at least a release in advance to give you time to make any necessary changes.

  • In the Java API, the init method of TangoTextureCameraPreview will be made private in the upcoming R release. This method was not meant to be made public.

Unity SDK Changes

  • The Unity SDK now includes a checkbox for config_enable_low_latency_imu_integration, which is enabled by default.

June 11, 2015: Pythagoras (KOT49H.150609)

OTA / General Changes

  • Simultaneous use of color and color texture callbacks is now supported.
  • Improved stability of the Tango framework.
  • Motion tracking is less likely to fail when the system is under high load.

Unity SDK Changes

  • The Unity SDK now includes a Google-Unity folder. This contains files shared by multiple Google Unity SDKs.

May 13, 2015: Nash (KOT49H.150505)

OTA / General Changes

  • Area description file names must be the same as their UUID. ADFs created using first party tools like Tango Explorer already comply with this requirement.
  • Performance of relocalization when using large ADFs has been improved.
  • The Mantis depth library has been updated to 1.9.0, which should reduce depth noise and error.

C API Changes

  • Callback functions now support an optional void* context argument. This allows proper binding of objects to callbacks using the Tango API.
  • Added the function TangoService_disconnectCamera().

Java API Changes

  • API reference documentation has been improved throughout.

  • If you are using depth data in Java, you will need to change to using the xyz field. An xyz field has been added to the TangoXyzIjData class, allowing for direct access to a FloatBuffer containing xyz points. Accessing the xyz field provides much more efficient access to the depth data over the previous implementations. As such, the getXyzBuffer() function has been deprecated and will be removed with the next release.

  • Added the function disconnectCamera() to the Tango class.
  • Added enums corresponding to calibration types to the TangoCameraIntrinsics class, bringing parity to the C API.
  • Added a KEY_BOOLEAN_COLORMODEAUTO param to the TangoConfig class. If true, enables auto-exposure and auto-white balance.
  • added a KEY_BOOLEAN_COLORCAMERA param to the TangoConfig class. Should be set to true if using the color camera.

Unity SDK Changes

  • The experimental VideoOverlayProvider has been changed to provide NV21 data through the texture provided by ExperimentalConnectTexture, bringing it in line with our other APIs. In our Unity sample code, we have an example of using a shader to convert the NV21 values to RGB in a shader. See the ARUnity sample under ExperimentalProjects - the shader can be found in assets/scripts/YUV2RGB.shader.
  • TangoUnityDepth has been modified to use float[] instead of Vector3[]. You will need to adjust your code if you recompile to Nash, but existing compiled apps will not be affected.
  • The read-only fields MAX_POINTS_ARRAY_SIZE and MAX_IJ_ARRAY_SIZE have been added to the TangoUnityDepth class. These files will return the maximum values supported by the specific device the application is installed on.
  • RenderLatestFrame now returns the timestamp.
  • The UX library has been released for Unity, and can be enabled in the Tango Manager. With the UX library, you can enable a standard connection screen and warning toasts to help users use a Tango device correctly.
  • The Tango Manager inspector now has collapsing contextual menus.
  • Added a link to documentation in the menu bar at Tango > Documentation.

  • Removed the unused enable ADF Save Load flag from the Tango Application script in the Tango Manager prefab.

April 29, 2015: Mandelbrot - Skipped

The Mandelbrot release was skipped.

April 15, 2015: Leibniz

OTA / General Fixes

  • Poses returned by Tango are now set to high rate and smooth by default. These settings can be controlled by Config flags: config_high_rate_pose and config_smooth_pose in C, KEY_BOOLEAN_HIGH_RATE_POSE and KEY_BOOLEAN_SMOOTH_POSE in Java. There is a known issue in this release that if the high rate pose flag is set to true, you must also set smooth pose to true.
  • Pose callbacks now run on a separate thread than depth and video, so callbacks may occur simultaneously. If those callbacks touch shared data, make sure to protect the data from race conditions.

C API Changes

  • TangoService_connectOnFrameAvailable() has been fixed so that TangoImageBuffer correctly provides YUV420SP instead of null.
  • config_enable_color_camera has been added to the configuration flags. We recommend you always explicitly set this flag to true if accessing the color camera. You must set the flag true for TangoService_connectOnFrameAvailable() or TangoService_connectTextureId() to succeed after TangoService_connect() is called.
  • The configuration flag config_depth_framerate has been removed. Devices will always use their fastest available depth framerate. For the Project Tango Tablet Development Kit, this rate is approximately 5 Hz.
  • NV21 has been added to the list of possible formats for camera preview.

Java API Changes

  • The TangoTextureCameraPreview class has been added to the Java API, providing a camera preview implemented using an Android TextureView. TangoCameraPreview, which uses GLSurfaceView, remains in the API. TextureViews are less efficient but more flexible than SurfaceView, allowing you to treat them as a regular View.
  • getTimestamp() has been added to the TangoCameraPreview class.

Unity SDK Changes

  • Unity samples have been migrated to Unity 5.
  • Tango data is now handled by thread-safe events instead of callbacks. This change requires you to change your implementation for any Tango data you are ingesting. For motion tracking based on our PoseController, this change consists of three lines:


    public class PoseController : PoseListener {


    public class PoseController : MonoBehaviour , ITangoPose {






    protected override void _OnPoseAvailable(IntPtr callbackContext, TangoPoseData pose)


    public void OnTangoPoseAvailable(Tango.TangoPoseData pose)

    See our updated samples and codelab for examples of the changes for motion tracking, area learning and depth.

  • Depth data now uses TangoUnityDepth. See the TangoUnityDepth class in TangoSDK/Core/Scripts/Common/TangoTypes.cs for details, and the Pointcloud script in our updated Unity depth sample for a usage example. Note that the vertices type has changed to a Vector3 from an array.

March 27, 2015: Kalman

OTA / General Fixes

  • Added experimental setting for faster but less accurate pose updates under Settings > Tango > Debugger Options > Use faster pose updates.

Java API Changes

  • Applications using older versions of the Java API jar file and connectSurface will no longer work. You must update to a current API file and use connectTextureId() to use OpenGL textures directly, or the TangoCameraPreview class, which inherits from GLSurfaceView.

Unity SDK Changes

  • Unity samples are separated from the SDK and hosted on GitHub.
  • The Unity SDK now uses the Tango client library in /system/lib instead of embedding its own version. To update existing projects to the latest SDK, you will need to manually remove the The Tango client library file. Do this by deleting from Assets/Plugins/Android in the project.
  • The experimental UX library is now disabled by default in the Unity SDK Tango Manager prefab.

March 17, 2015: Jacobi

OTA / General Fixes

  • Fixed bug that caused the touch panel to trigger a kernel panic.
  • Fixed critical issue with the MediaServer system component that caused the Camera app to crash.
  • Fixed memory leak in Tango Core. If the Tango Core app does not automatically update for you, go to the Play Store and manually update it. You'll need to close any apps running in the background and relaunch to guarantee they are running on the new Project Tango Core without problems.
  • Improved depth flash synchronization. Depth should be produced more reliably and flash should appear in color image less.
  • Improved motion tracking camera autogain now improves performance across lighting situations.
  • Improved system initialization for motion tracking to handle a wider range of motions such as stationary, rotating, translating, and roto-translating at medium and high rates.

C API Changes

  • Increased default depth framerate to 5 frames per second. A new config flag (config_depth_framerate) allows setting of depth framerate from 1 to 5 frames per second. See the Configuration Parameters module for more information.

Java API Changes

The Java API now uses JNI to communicate with Tango Service instead of AIDL. Several classes, methods, and fields have been updated in the Java API to correspond more closely with our C API. Here's a list of changes:

  • (Interface) OnTangoUpdateListener: Added the onFrameAvailable() method. Any class implementing this interface has to add this callback to have access to the camera RGB data.
  • Tango: The connectSurface method has been deprecated/removed. Developers should use connectTextureId() to use OpenGL textures directly, or the TangoCameraPreview class, which inherits from GLSurfaceView.
  • TangoCameraIntrinsics: Added fields to represent the different camera IDs (TANGO_CAMERA_COLOR, TANGO_CAMERA_DEPTH, TANGO_CAMERA_FISHEYE, TANGO_CAMERA_RGBIR)
  • TangoCameraPreview: This class is entirely new and is the way to get the camera preview. It inherits from GLSurfaceView, so developers who were using Tango.connectSurface() before should use this instead.
  • TangoConfig: Added fields for KEY_DOUBLE_DEPTHPERIODINSECONDS, KEY_INT_COLOREXP, KEY_INT_COLORISO, KEY_INT_MAXPOINTCLOUDELEMENTS, KEY_STRING_SERVICEVERSION. These correspond to the supported configuration parameters that can be queried, from the C Configuration Parameters module.
  • TangoEvent: Both the status and version fields, which were unused, have been eliminated.
  • TangoException, TangoInvalidException: TangoInvalidException now inherits from AndroidRuntimeException instead of TangoException.
  • TangoPoseData: Added an accuracy field added which corresponds to the one in the C TangoPoseData struct. Just like in C, this is unused as of yet, but reserved for reporting accuracy of the pose data.

Code Sample Updates

March 2, 2015: Ito

OTA / General

  • Sensor hub timestamp packets fixed. These caused an occasional crash of the motion tracking.
  • Fixed UART bug that caused a system resume fail. Improves interface between sensor hub and K1 chip.
  • Sensor hub firmware update with increased reliability of the wide angle camera.

Code Sample Changes

Application Changes

  • The Permissions Manager application functionality has been moved to Settings (Device > Tango > Enabled Apps)

February 18, 2015: Hilbert

OTA / General

  • Several stability improvements to the camera.
  • Auto-recovery lifecycle fixed.
  • The patches from Android Security Bulletin 2015 #1 have been applied.

C API Changes

  • The data format of the TangoImageBuffer struct has changed from HAL_PIXEL_FORMAT_YV12 to RGBA8888 format. Developers using the previous YV12 format should update their applications.

January 30, 2015: Gauss

OTA / General

  • The motion tracking camera has been improved for darker environments.

  • Depth reliability has been improved. If the depth system encounters a problem, in many cases it can now recover on its own. The color image may pause occasionally as depth attempts to recover you from errors.

  • The permissions flow has been streamlined so you only have to request permission once per app.

Unity SDK Changes

  • The Unity SDK has a more robust lifecycle with more reliable and faster starts and stops.

Java API Changes

Known Issues

  • The Tango Maps application currently will only recognize ADFs created by the Tango Maps Creator application. ADFs created by any other app can not be displayed by the Tango Maps app.

January 16, 2015: Fermat

OTA / General

  • Fixes to a bug that caused the camera app to crash upon opening.
  • Various fixes to the Tango pose lifecycle providing consistency between pose callbacks and pose queries. Also, provides stability during the initialization state for the ADF reference frame.

Known Issues

  • The device screen sometimes turns black and non-responsive, though it may still connect to ADB. Performing a hard reboot by holding down the POWER button for 10 seconds will make the screen responsive again.

December 2014: Euclid - Skipped

We skipped the Euclid release due to the holiday season.

December 18, 2014: Descartes

OTA / General

  • BlueTooth and A-GPS are enabled.
  • Improved camera stability and response on powerup, preventing a camera failure condition in Android.
  • Stabilized ADF file management so the device can handle ADF requests if ADFs are not present on your device. Also, added functionality to ADF creation including the ability to specify file names.
  • Performance improvements and bug fixes to the APIs and the watchdog daemon.

Unity SDK Changes

  • Improved lifecycle speed and reliability related to starting, pausing and exiting your Unity application.
  • Set a rotation on the PoseController in editor as Default.
  • Added support in area learning sample to save an ADF with specified file name, and load the saved file as default the next time the application is run.
  • Added wrappers for ADF Metadata functionality.

Apps Changes

  • Changed the sample code/apps package namespace to com.projecttango.experiments.
  • Scooter Viewer is no longer supported and has been removed from our downloads site.
  • Bug fixes to Tango Explorer, Area Manager, and Tango Maps.

November 26, 2014: Cantor

OTA / General

  • The Tango Core update (via OTA or Play Store) is aligned with the Cantor SDK/API release.
  • Fixed an issue with the touch screen becoming unresponsive during high heat levels.
  • Enabled a watchdog mechanism to prevent devices from locking up if an update hangs.
  • Devices will reboot automatically after a kernel panic.

API Updates

  • Callbacks are no longer required to be reconnected during the OnResume phase of the application lifecycle.

Unity SDK Changes

  • Removed internal Unity Tools from the SDK unitypackage.
  • Fixed slow startup times in Unity associated with requesting Tango permissions.
  • Fixed lifecycle issues that caused callbacks to be unregistered.
  • Fixed issue where applications could be backgrounded and permissions revoked, causing the application to become unresponsive on resume.
  • Refactored the initialization of the Tango Service. Now uses coroutines and an event to notify the developer that permissions have been accepted.

Fixes of Known Issues

  • Calibration: Getting extrinsics via getPoseAtTime() functions whenever you call it (regardless of whether you've called connect()).

November 14, 2014: Bernoulli

OTA / General

  • The ART runtime is now enabled as default, so users no longer have to switch from Dalvik.
  • The Tango Core update (via OTA from 1010A to 1024A version) now includes the following supported .so files:
  • In the current Bernoulli release, HDMI, Bluetooth, and A-GPS are turned off. We will share details on reenablement as soon as possible.
  • The battery charging software now sets a cutoff at 45 degrees Celsius, so devices should not overheat when charging.

API Updates

November 3, 2014: Archimedes

This is the first release to the public. Future releases will have notes with updates and changes to this build. Here are the current known issues with this release.

Known Issues


  • The current version of the Tango APIs are designed for a single app using Tango Service in the foreground. Multi-app usage is undefined so do not plan on users switching between multiple active Tango apps at this time.
  • Java applications should call connectSurface() before calling connect() if a surface is needed.
  • Cameras will occasionally crash and cannot be opened. For TangoApps, when they start, the API call TangoService_connect() will always return an error after 10 seconds and the app cannot continue. A reboot is usually required when this happens.
  • There is an issue with shutting down Unity applications via Application.Quit() once the API has been initialized.


  • The IJ buffer of the XYZij struct is under development and not yet populated via the API.
  • Occasionally, or when under high CPU load, the depth flash may appear in the color image, or no depth points are returned. Let the device cool down and/or reboot.


  • Getting extrinsics via getPoseAtTime() currently only functions after connect().
  • ADFs may become tilted with respect to gravity and you’ll find the horizon is no longer correct when relocalizing. You will need to delete the ADF and make a new one if this happens.

Color Camera

  • It is not yet possible to get YUV data in Unity.


  • Developers must use the ART runtime, the default runtime Dalvik is not supported.
  • The default landscape device orientation is uncommon. Some existing apps, especially those built with Unity, may not rotate correctly. See One Screen Turn Deserves Another for more information.
  • There is no manual method to submit feedback or bug reports yet, or a button-trigger to capture an Android bug report log.