<html devsite>
  <head>
    <title>Treble</title>
    <meta name="project_path" value="/_project.yaml" />
    <meta name="book_path" value="/_book.yaml" />
  </head>
  <body>
  <!--
      Copyright 2017 The Android Open Source Project

      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

      Unless required by applicable law or agreed to in writing, software
      distributed under the License is distributed on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      See the License for the specific language governing permissions and
      limitations under the License.
  -->


<p>The upcoming Android O release includes Project Treble, a major re-architect
of the Android OS framework designed to make it easier, faster, and less costly
for manufacturers to update devices to a new version of Android.</p>

<h2 id=about-treble>Android updates</h2>
<p>Project Treble separates the vendor implementation (device-specific,
lower-level software written by silicon manufacturers) from the Android OS
framework via a new vendor interface.</p>

<p>In Android 7.x and earlier, no formal vendor interface exists so device
makers must update large portions of the Android code to move a device to a
newer version of Android:</p>

<img src="images/treble_blog_before.png">

<p class="img-caption"><strong>Figure 1.</strong> Pre-Treble Android update
environment</p>

<p>With Treble, a new stable vendor interface provides access to the
hardware-specific parts of Android, enabling device makers to deliver new
Android releases simply by updating the Android OS framework&mdash;without any
additional work required from the silicon manufacturers:</p>

<img src="images/treble_blog_after.png">

<p class="img-caption"><strong>Figure 2.</strong> Treble Android update
environment</p>

<h2 id=testing-treble>Testing Treble</h2>
<p>To ensure forward compatibility of the vendor implementation, the new vendor
interface will be validated by the Vendor Test Suite (VTS), which is analogous
to the <a href="/compatibility/cts/">Compatibility Test Suite (CTS)</a>. VTS is
already launched and can be used to automate HAL and OS kernel testing even in
pre-Treble environments; for details, see
<a href="/devices/tech/test_infra/tradefed/fundamentals/vts">Systems Testing
With VTS</a>.</p>

<h2 id=launching-treble>Coming soon</h2>
<p>Project Treble is coming to all new devices launching with Android O and
beyond, and the new architecture is already running on the Developer Preview of
O for Pixel phones. When Android O launches, we'll have full details here (on
<a href="https://source.android.com/">source.android.com</a>). In the interim,
you can find more details on Treble over at the
<a href="https://android-developers.googleblog.com/2017/05/here-comes-treble-modular-base-for.html">Android
Developers Blog</a>.</p>


  </body>
</html>
