Chrome os development

Chrome os development DEFAULT

Chromium OS Developer Guide

Warning: This document is old & has moved. Please update any links:


This guide describes how to work on Chromium OS. If you want to help develop Chromium OS and you‘re looking for detailed information about how to get started, you’re in the right place. You can also use the quick-start guide instead, which gives just the basic steps that work for most people.

Target audience

The target audience of this guide is anyone who wants to obtain, build, or contribute to Chromium OS. That includes new developers who are interested in the project and who simply want to browse through the Chromium OS code, as well as developers who have been working on Chromium OS for a long time.

Organization & content

This guide describes the common tasks required to develop Chromium OS. The guide is organized linearly, so that developers who are new to Chromium OS can follow the tasks in sequence. The tasks are grouped into the following sections:

Typography conventions

  • Commands are shown with different labels to indicate whether they apply to (1) your build computer (the computer on which you're doing development), (2) the chroot (Chrome OS SDK) on your build computer, or (3) your Chromium OS computer (the device on which you run the images you build):
on your build computer, outside the chroot
inside the chroot on your build computer
on your build computer, either inside or outside the chroot
on your Chromium OS computer
  • Notes are shown using the following conventions:
    • IMPORTANT NOTE describes required actions and critical information
    • SIDE NOTE describes explanations, related information, and alternative options
  • TODO describes questions or work that is needed on this document

Modifying this document

If you're a Chromium OS developer, YOU SHOULD UPDATE THIS DOCUMENT and fix things as appropriate. See for how to update this document. Bias towards action:

  • If you see a TODO and you know the right answer, fix it!
  • If you see something wrong, fix it.
  • If you‘re not sure of the perfect answer, still fix it. Stick in a TODO noting your uncertainty if you aren’t sure, but don't let anything you know to be wrong stick around.

Please try to abide by the following guidelines when you modify this document:

  • Put all general “getting started” information directly on this page. It's OK if this document grows big.
  • If some information is also relevant for other documents, put the information in this document and add links from the other documents to this document. If you do not have a choice and must put information relevant to getting started in other documents, add links in this document to discrete chunks of information in the other documents. Following a web of links can be very confusing, especially for people who are new to a project, so it's very important to maintain a linear flow as much as possible.
  • Where possible, describe a single way of doing things. If you specify multiple options, provide a clear explanation why someone following the instructions would pick one option over the others. If there is disagreement about how to do things, consider listing alternative options in a SIDE NOTE.
  • Keep Google-specific references to a minimum. A large number of the people working on Chromium OS work at Google, and this document may occasionally contain references that are only relevant to engineers at Google. Google engineers, please keep such references to a minimum – Chromium OS is an open source project that should stay as open as possible.

More information

This document provides an overview of the tasks required to develop Chromium OS. After you've learned the basics, check out the links in the Additional information section at the end of this document for tips and tricks, FAQs, and important details (e.g., the Chromium OS directory structure, using the dev server, etc.).

Finally, if you build a Chromium OS image, please read this important note about Attribution requirements.


You must have Linux to develop Chromium OS. Any recent or up-to-date distribution should work. However, we can‘t support everyone and their dog’s Linux distro, so the only official supported environment is listed below. If you encounter issues with other setups, patches are generally welcomed, but please do not expect us to figure out your distro.

  • Ubuntu Linux (version 16.04 - Xenial)

    Most developers working on Chromium OS are using Xenial (the LTS version of Ubuntu) and Debian testing. It is possible that things will work if you‘re running a different Linux distribution, but you will probably find life easier if you’re on one of these.

  • an x86_64 64-bit system for performing the build

  • an account with access

    You need root access to run the command and to modify the mount table. NOTE: Do not run any of the commands listed in this document as root – the commands themselves will run sudo to get root access when needed.

  • many gigabytes of RAM

    Per this thread, linking Chrome requires somewhere between 8 GB and 28 GB of RAM as of March 2017; you may be able to get by with less at the cost of slower builds with adequate swap space. Seeing an error like while building the package indicates that you need more RAM. If you are not building your own copy of Chrome, the RAM requirements will be substantially lower.

You will have a much nicer time if you also have:

  • a fast multi-processor machine with lots of memory

    The build system is optimized to make good use of all processors, and an 8 core machine will build nearly 8x faster than a single core machine.

  • a good Internet connection

    This will help for the initial download (minimum of about 2 GB) and any further updates.

Install git and curl

Install the git revision control system, the curl download helper, and lvm tools. On Ubuntu 16.04, the magic incantation to do this is (all on one line):

(outside) sudo apt-get install git-core gitk git-gui curl lvm2 thin-provisioning-tools \ python-pkg-resources python-virtualenv python-oauth2client xz-utils \ python3.6

More recent Debian-based distributions (such as Googlers' workstations) might qualify the Python package names and you'll need to run this instead:

(outside) sudo apt-get install git-core gitk git-gui curl lvm2 thin-provisioning-tools \ python3-pkg-resources python3-virtualenv python3-oauth2client xz-utils \ python3.6

These command also installs git's graphical front end () and revision history browser ().

If Python 3.5 is the default, switch it to at least Python 3.6. You can check what version you're using with:

(outside) python3 --version

If the above says 3.5, or below, you'll need to switch it to 3.6+ (Googlers should be wary of modifying any python configurations). This can be done with:

(outside) sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.51 sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.62 sudo update-alternatives --config python3

Install depot_tools

To get started, follow the instructions at install depot_tools. This step is required so that you can use the repo command to get/sync the source code.

Tweak your sudoers configuration

You must tweak your sudoers configuration to turn off the tty_tickets option as described in Making sudo a little more permissive. This is required for using .

Set locale

These may not be needed if you are building on a system that you already use, however if you have a clean instance on GCE, you'll need to set a better locale. For example, on Debian Buster on GCE, do:

(outside) sudo apt-get install locales sudo dpkg-reconfigure locales

When running , choose a language with UTF-8, e.g. . For this change to take effect, you will need to log out and back in (closing all term windows, tmux/screen sessions, etc.).

Configure git

Setup git now. If you don't do this, you may run into errors/issues later. Replace and with your information:

(outside) git config --global "[email protected]" git config --global "Your Name"

Preparations to submit changes

IMPORTANT NOTE: If you are new to Chromium OS, you can skip this step (go to “Decide where your source will live”). This is only for people who wish to make changes to the tree. Remember: anyone can post changes to Gerrit for review.

Follow the instructions here to setup your code review account(s) and machine access credentials for the source repos. Remember a account is not required to submit code for review.

Double-check that you are running a 64-bit architecture

Run the following command:

(outside) uname -m

You should see the result:

If you see something else (for example, , which means you are on a 32-bit machine or a 64-bit machine running a 32-bit OS) then you won't be able to build Chromium OS. The project would happily welcome patches to fix this.

Verify that your default file permissions (umask) setting is correct

Sources need to be world-readable to properly function inside the chroot (described later). For that reason, the last digit of your umask should not be higher than 2, eg. ‘002’ or ‘022’. Many distros have this by default, Ubuntu, for instance, does not. It is essential to put the following line into your file before you checkout or sync your sources.

(outside) umask 022

You can verify that this works by creating any file and checking if its permissions are correct.

(outside) touch ~/foo ls -la ~/foo -rw-r--r--1 user group 02012-08-3023:09/home/user/foo

Get the Source

Decide where your source will live

Chromium OS developers commonly put their source code in . If you feel strongly, put your own source elsewhere, but note that all commands in this document assume that your source code is in.

Create the directory for your source code with this command:

(outside) mkdir -p ~/chromiumos

IMPORTANT NOTE: If your home directory is on NFS, you must place your code somewhere else. Not only is it a bad idea to build directly from NFS for performance reasons, but builds won‘t actually work (builds use sudo, and root doesn’t have access to your NFS mount, unless your NFS server has the option). Wherever you place your source, you can still add a symbolic link to it from your home directory (this is suggested), like so:

(outside) mkdir -p /usr/local/path/to/source/chromiumos ln -s /usr/local/path/to/source/chromiumos ~/chromiumos

Get the source code

Chromium OS uses repo to sync down source code. is a wrapper for the git that helps deal with a large number of repositories. You already installed when you installed above.

Make sure you have followed the gerrit credentials setup instructions here.


(outside) cd ~/chromiumos repo init -u --repo-url repo sync -j4

Googlers/internal manifest:

(outside) cd ~/chromiumos repo init -u --repo-url -b stable repo sync -j4

For Googlers: the instructions above add to the init instructions vs the external version without. This feature is known as “sync-to-green”; the version of the source that you will sync to is 5-10 hours old but is guaranteed to be verified by our CI system and have prebuilt binaries available. For more information about this see Sync to Green.

Note: tells to concurrently sync up to 4 repositories at once. You can adjust the number based on how fast your internet connection is. For the initial sync, it's generally requested that you use no more than 8 concurrent jobs. (For later syncs, when you already have the majority of the source local, using -j16 or so is generally okay.)

Note: If you are on a slow network connection or have low disk space, you can use the option. This starts you out with a minimum amount of source code. This isn't a particularly well tested configuration and has been known to break from time-to-time, so we usually recommend against it.

Optionally add Google API keys

Secondly, decide whether you need to use features of Chromium that access Google APIs from the image you are building (signing in, translating web pages, geolocation, etc). If the answer is yes, you will need to have keys (see API Keys) either in your include.gypi, or in a file in your home directory called “.googleapikeys”. If either of these file are present for step 1 of building (below) they will be included automatically. If you don't have these keys, these features of chromium will be quietly disabled.

Branch Builds

If you want to build on a branch, pass the branch name to repo init (e.g: ).

When you use you will be asked to confirm your name, email address, and whether you want color in your terminal. This command runs quickly. The command takes a lot longer.

More info can be found in the working on a branch page.

Make sure you are authorized to access Google Storage (GS) buckets

Building and testing Chromium OS requires access to Google Storage. This is done via gsutil. Once configured, an authorization key is placed in . Every time you access the chroot via , the file is copied to the chroot. If you run gsutil inside the chroot, it will configure the key in the chroot version of , but every time you re-run , it will overwrite the file in the chroot.

Building Chromium OS

Create a chroot

To make sure everyone uses the same exact environment and tools to build Chromium OS, all building is done inside a chroot. This chroot is its own little world: it contains its own compiler, its own tools (its own copy of bash, its own copy of sudo), etc. Now that you‘ve synced down the source code, you need to create this chroot. Assuming you’re already in (or wherever your source lives), the command to download and install the chroot is:

(outside) cros_sdk

If this does not work, make sure you've added the depot_tools directory to your PATH already (as was needed above with using ).

This will download and setup a prebuilt chroot from Chromium OS mirrors (under 400M). If you prefer to rather build it from source, or have trouble accessing the servers, use . Note that this will also enter the chroot. If you prefer to build only, use .

The command with takes about half an hour to run on a four core machine. It compiles quite a bit of software, which it installs into your chroot, and downloads some additional items (around 300MB). While it is building you will see a regular update of the number of packages left to build. Once the command finishes, the chroot will take up total disk space of a little over 3GB.

The chroot lives by default at . Inside that directory you will find system directories like and . These are local to the chroot and are separate from the system directories on your machine. For example, the chroot has its own version of the utility. It will be very similar, but it is actually a different binary than the normal one you use on your machine.


  • You shouldn't have to create the chroot very often. Most developers create it once and never touch it again unless someone explicitly sends out an email telling them to recreate their chroot.
  • The command currently doesn't work behind a proxy server, but there is a workaround.

Enter the chroot

Most of the commands that Chromium OS developers use on a day-to-day basis (including the commands to build a Chromium OS image) expect to be run from within the chroot. You can enter the chroot by calling:

(outside) cros_sdk

This is the same command used to create the chroot, but if the chroot already exists, it will just enter.

NOTE: if you want to run a single command in the chroot (rather than entering the chroot), prefix that command with .

This command will probably prompt you for your password for the command (entering the chroot requires root privileges). Once the command finishes, that terminal is in the chroot and you'll be in the directory, where most build commands live. In the chroot you can only see a subset of the filesystem on your machine. However, through some trickery (bind mounts), you will have access to the whole directory from within the chroot – this is so that you can build the software within the chroot.

Note in particular that the directory is the same directory found within the Chromium OS directory you were in before you entered the chroot, even though it looks like a different location. That's because when you enter the chroot, the directory in the chroot is mounted such that it points to the main Chromium OS directory . That means that changes that you make to the source code outside of the chroot immediately take effect inside the chroot.

Calling this will also install a chroot, if you don't have one yet, for example by not following the above.

While in the chroot you will see a special “(cr)” prompt to remind you that you are there:

(cr)((...)) [email protected] ~/trunk/src/scripts $

You generally cannot run programs on your filesystem from within the chroot. For example, if you are using eclipse as an IDE, or gedit to edit a text file, you will need to run those programs outside the chroot. As a consolation, you can use vim. If you are desperate for emacs, try typing . Of course this command will build emacs from source so allow 5-10mins.


  • If you need to delete your chroot, use to delete it properly. Using could end up deleting your source tree due to the active bind mounts.


  • If you need to share lots of files inside and outside chroot (for example, settings for your favorite editor / tools, or files downloaded by browser outside chroot, etc.), read Tips and Tricks.
  • There is a file system loop because inside you will find the chroot again. Don‘t think about this for too long. If you try to use you might get a message about a corrupted file system. This is nothing to worry about, and just means that your computer doesn’t understand this loop either. (If you can understand this loop, try something harder.)

Select a board

Building Chromium OS produces a disk image (usually just called an “image”) that can be copied directly onto the boot disk of a computer intended to run Chromium OS. Depending on the specifics of that computer, you may want different files in the disk image. For example, if your computer has an ARM processor, you‘ll want to make sure that all executables in the image are compiled for the ARM instruction set. Similarly, if your computer has special hardware, you’ll want to include a matching set of device drivers.

Different classes of computers are referred to by Chromium OS as different target “boards”. The following are some example boards:

  • amd64-generic - builds a generic image suitable for computers with an x86_64-compatible CPU (64 bit) or for running in a VM
  • arm-generic - builds a generic image suitable for computers with an ARM CPU (32 bit)
  • arm64-generic - builds a generic image suitable for computers with an ARM CPU (64 bit)
  • samus, eve, <your board name> - builds an image specific to the chosen device (find your board name here); recommended for deploying to official hardware
  • betty - (Googlers only) builds an ARC++-enabled image for running in a VM

You need to choose a board for your first build. Be aware that the generic images may not work well (or not at all) when run on official hardware. Don't worry too much about this choice, though – you can always build for another board later. If you want a list of known boards, you can look in .

Each command in the build processes takes a parameter. To facilitate this, it can be helpful to keep the name of the board in a shell variable. This is not strictly necessary, but if you do this, you can simply copy and paste the commands below into your terminal program. Enter the following inside your chroot:

(inside) export BOARD=<your pick of board>

This setting only holds while you stay in the chroot. If you leave and come back, you need to specify this setting again.


  • If you look at , you may notice two different naming patterns: and (note the dash here). If you intend to build for particular board variant, you'll want to use pair (note the underscore here) as your board name. E.g. for overlay-variant-peach-pi the correct value for would be .

Initialize the build for a board

To start building for a given board, issue the following command inside your chroot (you should be in the directory):

(inside) setup_board --board=${BOARD}

This command sets up the board target with a default sysroot of . The command downloads a small amount of stuff and takes a few minutes to complete. also calls , which will update the toolchain if has been run and the toolchain is out of date.


  • If you pass the flag to , the command writes the board name in the file (it does the same thing as ). This makes it so that you don't need to specify a argument to subsequent commands. These instructions do not use the flag so that you can explicitly see what commands are board-specific.
  • If you want to clobber your old board files and start fresh, try passing the flag, which deletes the old directory for you. Like , most people only re-run when told to (they don't re-run it even after a ).
  • You can delete the board sysroot at any time with:

Set the chronos user password

On a Chromium OS computer, you can get command line access (and root access through the command) by logging in with the shared user account . You should set a password for the user by entering the command below from inside the directory:


You will be prompted for a password, which will be stored in encrypted form in .


  • The encrypted password is stored inside chroot. That means that if you recreate your chroot, you have to run this command again.
  • If you don't set a shared user password, the password for the chronos account may end up being any number of things depending on some complicated (and constantly evolving) formula that includes whether you build a developer image, whether you boot into Developer Mode, and the current state of the scripts. The password might be empty, or a well-known string (such as on test images), or it might be impossible to login with chronos. It is strongly recommended that you simply set a shared user password. TODO: put a link to some place with more info about this.

Build the packages for your board

To build all the packages for your board, run the following command from inside the directory:

(inside)./build_packages --board=${BOARD}

This step is the rough equivalent of in a standard Makefile system. This command handles incremental builds; you should run it whenever you change something and need to rebuild it (or after you run ).

Normally, the build_packages command builds the stable version of a package (i.e. from committed git sources), unless you are working on a package (with ). If you are working on a package, build_packages will build using your local sources. See below for information about .


  • Like , also calls , which will update the toolchain if has been run and the toolchain is out of date.

  • Even though there are some flags that can optimize your build (like , --nowithautotest, etc), you should not use these flags (even if you don't plan on building a developer / test image). There are some issues with virtual packages that can cause some hard-to-debug differences if you use one of these flags.

  • The flag is an exception to the previous point. By default, packages other than Chrome will be compiled in debug mode; that is, with undefined and with debugging constructs like , , and the red “Debug image” message present. If you supply , then will be defined and the debugging constructs will be removed.

  • The first time you run the command, it will take a long time (around 90 minutes on a four core machine), as it must build every package, and also download about 1.7GB of source packages and 1.3GB of binary packages. See here for more information about what the build_packages command actually does. In short, it tries to download existing binary packages to avoid building anything (and puts them in for subsequent builds). Failing that, it downloads source packages, puts them in , and builds them.

Build a disk image for your board

Once the step is finished, you can build a Chromium OS-base developer image by running the command below from inside the directory:

(inside)./build_image --board=${BOARD}--noenable_rootfs_verification test

The args for specify what type of build you want. A test image (in the example above) has additional test-specific packages and also accepts incoming ssh connections. It is more convenient to use test images, but developers could also build developer images. A developer image provides a Chromium OS-based image with additional developer packages. To build it use instead of . If building a test image, the password set using will be ignored and will be the password instead. The turns off verified boot allowing you to freely modify the root file system. The system is less secure using this flag, however, for rapid development you may want to set this flag. If you would like a more secure, locked-down version of Chromium OS, then simply remove the flag. Finally if you want just the pristine Chromium OS-based image (closest to Chrome OS but not quite the same), pass in rather than or . Use for more information.

The image produced by build_image will be located in (where will actually be a version number). The most recent image produced for a given board will be symlinked to .

IMPORTANT NOTE: It‘s up to you to delete old builds that you don’t need. Every time you run , the command creates files that take up to 8GB of space(!).

Look at your disk image (optional)

The preferred way to mount the image you just built to look at its contents is:

(inside)./ --board=${BOARD}--safe --most_recent

If you built a test image, also make sure to add to this command.

The option ensures you do not make accidental changes to the Root FS.

Again, don‘t forget to unmount the root filesystem when you’re done:

(inside)./ --board=${BOARD}-u

Optionally, you can unpack the partition as separate files and mount them directly:

(inside) cd ~/trunk/src/build/images/${BOARD}/latest ./ chromiumos_image.bin mkdir -p rootfs sudo mount -o loop,ro part_3 rootfs

This will do a loopback mount of the rootfs from your image to the location in your chroot.

If you built with you can omit the “ro” option to mount it read write.

If you built an x86 Chromium OS image, you can probably even try chrooting into the image:

(inside) sudo chroot ~/trunk/src/build/images/${BOARD}/latest/rootfs

This is a little hacky (the Chromium OS rootfs isn‘t really designed to be a chroot for your host machine), but it seems to work pretty well. Don’t forget to this chroot when you're done.

When you're done, unmount the root filesystem:

(inside) sudo umount ~/trunk/src/build/images/${BOARD}/latest/rootfs

Installing Chromium OS on your Device

Put your image on a USB disk

The easiest way to get your image running on your target computer is to put the image on a USB flash disk (sometimes called a USB key), and boot the target computer from the flash disk.

The first step is to disable auto-mounting of USB devices on your build computer as it may corrupt the disk image while it's being written. On systems that use GNOME or Cinnamon, run the following:

gsettings set automount false gsettings set automount-open false gsettings set automount false gsettings set automount-open false

Next, insert a USB flash disk (8GB or bigger) into your build computer. This disk will be completely erased, so make sure it doesn't have anything important on it. Wait ~10 seconds for the USB disk to register, then type the following command:

(inside) cros flash usb:// ${BOARD}/latest

For more details on using this tool, see the Cros Flash page.

When the command finishes, you can simply unplug your USB key and it's ready to boot from.

IMPORTANT NOTE: To emphasize again, completely replaces the contents of your USB disk. Make sure there is nothing important on your USB disk before you run this command.


  • If you want to create a test image (used for integration testing), see the Running Tests section.

Enter Developer Mode

See the Developer Mode documentation.

Boot from your USB disk

After enabling Developer Mode, you should set your system to boot from USB.

Let the device boot, login and open a shell (or switch to terminal 2 via Ctrl+Alt+F2).

Run the following command:

(device) sudo crossystem

You should see equal to 0. Set it to 1 to enable USB boot:

(device) sudo crossystem dev_boot_usb=1

Now reboot. On the white screen (indicating Developer Mode is enabled), plug-in the USB disk and press (Debug Button Shortcuts).

Installing your Chromium OS image to your hard disk

Once you've booted from your USB key and gotten to the command prompt, you can install your Chromium OS image to the hard disk on your computer with this command:


IMPORTANT NOTE: Installing Chromium OS onto your hard disk will WIPE YOUR HARD DISK CLEAN.

Getting to a command prompt on Chromium OS

Since you set the shared user password (with ) when you built your image, you have the ability to login as the chronos user:

  1. After your computer has booted to the Chromium OS login screen, press to get a text-based login prompt. ( may appear as on your Notebook keyboard.)
  2. Login with the chronos user and enter the password you set earlier.

Because you built an image with developer tools, you also have an alternate way to get a terminal prompt. The alternate shell is a little nicer (in the very least, it keeps your screen from dimming on you), even if it is a little harder to get to. To use this alternate shell:

  1. Go through the standard Chromium OS login screen (you‘ll need to setup a network, etc.) and get to the web browser. It’s OK to login as guest.
  2. Press to get the crosh shell.
  3. Use the command to get the shell prompt. NOTE: you don't need to enter the password here, though you will still need the password if you want to use the command.

Building an image to run in a virtual machine

Many times it is easier to simply run Chromium OS in a virtual machine like kvm. You can adapt the previously built Chromium OS image so that it is usable by (which uses qemu images) by entering this command from the directory:

(inside)./ --board=${BOARD}

This command creates the file .


  • WARNING: After crbug/710629, ‘betty’ is the only board regularly run through pre-CQ and CQ VMTest and so is the most likely to work at ToT. ‘betty’ is based on ‘amd64-generic’, though, so ‘amd64-generic’ is likely to also work.
  • Only KVM/QEMU VM's are actively supported at the moment.
  • If you built a image, you also need to add the flag.
  • You can specify source/destination paths with the and parameters.
  • If you're interested in creating a test image (used for integration testing), see the Running Tests section.

Making changes to packages whose source code is checked into Chromium OS git repositories

Now that you can build and run Chromium OS, you're ready to start making changes to the code.

NOTE: If you skipped to this section without building your own system image, you may run into hard-to-fix dependency problems if you build your own versions of system packages and try to deploy them to a system image that was built by a builder. If you run into trouble, try going through the full Building Chromium OS process first and installing your own system image.

Keep the tree green

Before you start, take a moment to understand Chromium's source management strategy of “keeping the tree green”. For the Chromium OS project, keeping the tree green means:

  1. Any new commits should not destabilize the build:
    • Images built from the tree should always have basic functionality working.
    • There may be minor functionality not working, and it may be the case, for example, that you will need to use Terminal to fix or work around some of the problems.
  2. If you must introduce unstable changes to the tree (which should happen infrequently), you should use parameterization to hide new, unstable functionality behind a flag that's turned off by default. The Chromium OS team leaders may need to develop mechanisms for parameterizing different parts of the system (such as the init script).
  3. Internal “dev channel” releases will be produced directly from the tree, with a quick branch to check-point the release version. Any fixes required for a release will be pulled from the tree, avoiding merges back to tree.

This strategy has many benefits, including avoiding separate build trains for parallel development (and the cost of supporting such development), as well as avoiding large, costly merges from forked branches.

SIDE NOTE: “Keep the tree green” means something a bit different for Chromium OS than for Chromium, which is much further along in its life cycle.

The steps in this section describe how to make changes to a Chromium OS package whose source is checked into the Chromium OS source control system. Specifically, this is a package where:

  • The for the package lives in the or directories.
  • There is an ebuild for the package that ends with .
  • The ebuild inherits from the class.
  • The ebuild has a in the ebuild containing this architecture name (like “”).

You can see a list of all such packages by running the following command from inside the directory:

(inside) cros_workon --board=${BOARD}--all list

Run cros_workon start

The first thing you need to do is to mark the package as active. Use the command below, replacing with your package name (e.g., ):

(inside) cros_workon --board=${BOARD} start ${PACKAGE_NAME}

This command:

  • Indicates that you'd like to build the version of the instead of the stable, committed version.
  • Indicates that you'd like to build from source every time.
  • If you specified that you wanted the when you did your , this command adds a clause to your to tell to sync down the source code for this package next time you do a .

Run repo sync

After running , sync down the sources. This is critical if you‘re using the , but is probably a good idea in any case to make sure that you’re working with the latest code (it'll help avoid merge conflicts later). Run the command below anywhere under your directory:

(in/out) repo sync

Find out which ebuilds map to which directories

The tool can help you find out what ebuilds map to each directory. You can view a full list of ebuilds and directories using the following command:

(inside) cros_workon --board=${BOARD}--all info

If you want to find out which ebuilds use source code from a specific directory, you can use grep to find them. For example:

(inside) cros_workon --board=${BOARD}--all info | grep platform/ec

This returns the following output:

chromeos-base/ec-utils chromiumos/platform/ec src/platform/ec

This tells you the following information:

  1. The name of the ebuild is
  2. The path to the git repository on the server is
  3. The path to the source code on your system is

You can similarly find what source code is associated with a given ebuild by grepping for the ebuild name in the list.

To find out where the ebuild lives:

(inside) equery-${BOARD} which ${PACKAGE_NAME}

As an example, for , the above command might display:


SIDE NOTE: If you run the same command without running first, you can see the difference:


Create a branch for your changes

Since Chromium OS uses /, you should always create a local branch whenever you make changes.

First, find the source directory for the project you just used on. This isn‘t directly related to the project name you used with . (This isn’t very helpful - someone with more experience, actually tell us how to find it reliably? --Meredydd)

cd into that directory, in particular the directory in which the actual source resides. In the command below, replace with a name that is meaningful to you and that describes your changes (nobody else will see this name):

(in/out) repo start ${BRANCH_NAME}.

The branch that this creates will be based on the remote branch (which one? --Meredydd). If you've made any other local changes, they will not be present in this branch.

Make your changes

You should be able to make your changes to the source code now. To incrementally compile your changes, use either or . To use , run

(inside) cros_workon_make --board=${BOARD} ${PACKAGE_NAME}

This will build your package inside your source directory. Change a single file, and it will rebuild only that file and re-link. If your package contains test binaries, using

(inside) cros_workon_make --board=${BOARD} ${PACKAGE_NAME}--test

will build and run those binaries as well. Call to see other options that are supported.

You probably want to get your changes onto your device now. You need to install the changes you made by using

(inside) cros_workon_make --board=${BOARD} ${PACKAGE_NAME}--install

You can then rebuild an image with and reimage your device.

Alternatively, you can build your package using and quickly install it to the device by using cros deploy.

For example, if you want to build to test on your device, use

(inside) emerge-${BOARD} ec-utils

To install the package to the device, use

(inside) cros deploy ${IP} ec-utils

Set your editor

Many of the commands below (in particular ) open up an editor. You probably want to run one of the three commands below depending on your favorite editor.

If you're not a *nix expert, is a reasonable editor:

export EDITOR='nano'

If you love :

export EDITOR='vi'

If you love (and don't want an X window to open up every time you do something):

export EDITOR='emacs -nw'

You should probably add one of those lines to your (or similar file) too.

Submit changes locally

When your changes look good, commit them to your local branch using . Full documentation of how to use git is beyond the scope of this guide, but you might be able to commit your changes by running something like the command below from the project directory:

(in/out) git commit -a

The git commit command brings up a text editor. You should describe your changes, save, and exit the editor. Note that the description you provide is only for your own use. When you upload your changes for code review, the repo upload command grabs all of your previous descriptions, and gives you a chance to edit them.

Upload your changes and get a code review

Check out our Gerrit Workflow guide for details on our review process.

Clean up after you're done with your changes

After you‘re done with your changes, you’re ready to clean up. The most important thing to do is to tell that you're done by running the following command:

(inside) cros_workon --board=${BOARD} stop ${PACKAGE_NAME}

This command tells to stop forcing the and to stop forcing a build from source every time.

If you're using the , doing a stop will not remove your source code. The code will continue to stay on your hard disk and get synced down.

Making changes to non-cros_workon-able packages

If you want to make changes to something other than packages which source is checked into the Chromium OS source control system, you can follow the instructions in the previous section, but skip the step. Note specifically that you still need to run to Create a branch for your changes.

The types of changes that fall into this category include:

  • changes to build scripts (pretty much anything in )
  • changes to files themselves (like the ones in )
    • To change these files, you need to “manually uprev” the package. For example, if we're making a modification to for the Pixel overlay (link), then
    • is a symlink that points to . To uprev the package, simply increment the revision (r29) number.
    • Note: Upreving should not be done when there is an ebuild for the package that ends with . Changes to the ebuild should usually be done in the file.
  • adding small patches to existing packages whose source code is NOT checked into Chromium OS git repositories
  • changes to files (like the ones in )
  • changes to the buildbot infrastructure (in )
  • changes to Chromium OS project documentation (in )
  • TODO: anything else?

Adding small patches to existing packages

When you need to add small patches to existing packages whose source code is not checked into a Chromium OS git repository (e.g. it comes from portage, and is not a -able package), you need to do the following:

First, find the package ebuild file under .

Then, create a patch file from the exact version of the package that is used by the current ebuild. If other patches are already in the ebuild, you'll want to add your patch LAST, and build the patch off of the source that has already had the existing patches applied (either do it by hand, or set and build your patch off of the temp source). Note that patch order is significant, since the ebuild expects each patch line number to be accurate after the previous patch is applied.

Place your patch in the “files” subdir of the directory that contains the ebuild file (e.g. ).

Then, in the section of the ebuild (create one if it doesn't exist), add an epatch line:

epatch "${FILESDIR}"/${P}-my-little-patch.patch

Lastly, you'll need to bump the revision number in the name of the ebuild file (or symlink) so the build system picks up the change. The current wisdom is that the ebuild file should be symlinked instead of being renamed. For example, if the original ebuild file is , you should create a symbolic link that points at the original ebuild file. If that symlink already exists, create the next higher “rN” symlink.

Making changes to the way that the chroot is constructed

TODO: This section is currently a placeholder, waiting for someone to fill it in. However, a few notes:

  • Many of the commands that take a parameter also take a parameter, which makes the commands affect the host (i.e. the chroot) rather than the board.
    • Most notably, says that you want to build a package used in the chroot from source.

Building an individual package

TODO: Document this better, and add the new .

SIDE NOTE: To build an individual portage package, for a particular board, use .

For example, if you want to build dash to test on your device:

(inside) emerge-${BOARD} dash

To install the package to the device, see cros deploy.


  • Typically, when building a package with , the dependencies have already been built. However, in some situations dependencies will need to be built as well. When that happens, can be passed to to build different packages in parallel.

Making changes to the Chromium web browser on Chromium OS

If you just want to make modifications to the Chromium web browser and quickly deploy your changes to an already-built Chromium OS image, see Making changes to the Chromium web browser on Chromium OS.

To use your local checkout of the Chromium source code when building a Chromium OS image, set the flag appropriately when entering the chroot, e.g.

(outside) cros_sdk --chrome_root=~/chrome

Within the chroot, you'll also need to either start working on the and packages:

(inside) cros_workon --board=${BOARD} start chromeos-chrome chrome-icu

or set the environment variable appropriately:


See for additional possible values for the variable.

If you have an internal checkout of the Google Chrome source and want to build the browser with official branding, export .

Using Clang to get better compiler diagnostics


The ChromeOS toolchain provides a feature to get Clang syntax-only compiler diagnostics without having to do a separate build with the Clang compiler. To enable this feature, add to the used by the package for its build.

Addition of the option to the build is interpreted by the compiler driver wrapper script, which then invokes Clang with -fsyntax-only option, and after a successful Clang run, invokes the gcc compiler. Any errors generated by Clang will stop compilation just like a regular build does. In addition to Clang warnings, you will also see warning from gcc, in some cases for the same source construct.

The presence of a few specific gcc options, for example, or will disable a clang run, even if is specified. This is to allow package configure scripts to run correctly even in the presence of the option.

Wrapper Options

The wrapper script also interprets a few other options. All options specific to the wrapper only are tabulated below:

  • : Invoke Clang front-end with and all other options specified on the command line. On successful completion of Clang compile, continue the build with gcc or . The presence of , , , , or will disable clang invocation.
  • : This is a special option that can be used to pass to Clang and not to or . This can be used, for example, to turn off a specific Clang warning. Example: s will add to the Clang invocation.
  • : In addition to doing the builds, print the exact command-line used for both Clang and gcc.


You can test your package with Clang before adding to your ebuild or Makefiles using the or variable. While using this, you need to be careful not to overwrite existing or . Here's an example:

(inside) $ CFLAGS="$(portageq-$board envvar CFLAGS) -clang" \ CXXFLAGS="$(portageq-$board envvar CXXFLAG) -clang" \ emerge-$board chromeos-chrome

After your package builds cleanly with Clang, you can add to your ebuild.

Local Debugging

Debugging both x86 and non-x86 binaries on your workstation.

If you build your projects incrementally, write unit tests and use them to drive your development, you may want to debug your code without shipping it over to a running device or VM.

sets up gdb in your board sysroot and ensures that gdb is using the proper libraries, debug files, etc. for debugging, allowing you to run your target-compiled binaries.

It should already be installed in your chroot. If you do not have the script, update your repository to get the latest changes, then re-build your packages:

(in/out) repo sync (inside)./build_packages --board=...

This should install in the directory inside the chroot. These board-specific gdb wrapper scripts correctly handle both local and remote debugging (see next section for more information on remote debugging). When used for local debugging, these scripts will run inside a special chroot-inside-your-chroot, rooted in the board's sysroot. For example if you are using , it will run inside a chroot based entirely in your sysroot. The libraries that it will load and use are the libraries in the sysroot, i.e. the target libraries for the board; the gdb binary it will use is the gdb binary in that tree. While debugging with (for local debugging), you will not be able to see/access any files outside of the tree. While for the most part this is very good, as it ensures the correct debugging environment, it does mean that if you want to use this script to debug a lumpy binary, such as a unit test, that you built outside of the tree, you will need to copy the binary to the tree first. Also, if you want the debugger to be able to see the source files when debugging, you will need to make sure they exist inside the tree as well (see example below).

IMPORTANT NOTE 1: Local and remote debugging functionality are combined in this single script. Some of the options shown below only work for remote debugging.

IMPORTANT NOTE 2: When doing local debugging of x86 binaries, they will try to execute on your desktop machine (using the appropriate libraries and gdb binaries). It is possible that for some x86 boards, the binaries may use instructions not understood by your hardware (particularly some vector instructions), in which case you will need to do remote debugging with the actual hardware instead.

IMPORTANT NOTE 3: You can use this script with *some* debugging functionality for local debugging of non-x86 binaries. The script loads qemu and runs the non-x86 binaries in qemu. However qemu has some unfortunate limitations. For example you can “set” breakpoints in the binary (to see what addresses correspond to locations in the source), examine the source or assembly code, and execute the program. But qemu does not actually hit the breakpoints, so you cannot suspend execution in the middle when running under qemu. For full debugging functionality with non-x86 binaries, you must debug them remotely running on the correct hardware (see next section on remote debugging). You can see this in the example below, where gdb-daisy does not actually stop at the breakpoint it appears to set, although it does correctly execute the program.

(inside)(cr) $ gdb-daisy -h usage: cros_gdb [-h][--log-level {fatal,critical,error,warning,notice,info,debug}][--log_format LOG_FORMAT][--debug][--nocolor][--board BOARD][-g GDB_ARGS][--remote REMOTE][--pid PID][--remote_pid PID][--no-ping][--attach ATTACH_NAME][--cgdb][binary-to-be-debugged][args-for-binary-being-debugged]Wrapperfor running gdb.This handles the fun details like running against the right sysroot, via qemu, bind mounts, etc... positional arguments: inf_args Argumentsfor gdb to pass to the program being debugged.These are positional and must come at the end of the command line.This will not work if attaching to an already running program....(cr) $ gdb-daisy /bin/grep shebang /bin/ls 15:51:06: INFO: run: file /build/daisy/bin/grep Reading symbols from /bin/grep...Reading symbols from /usr/lib/debug/bin/grep.debug...done.done.(daisy-gdb) b main Breakpoint1 at 0x2814: file grep.c, line 2111.(daisy-gdb) disass main Dump of assembler code forfunction main:0x00002814<+0>: ldr.w r2,[pc,#3408] ; 0x3568 <main+3412>0x00002818<+4>: str.w r4,[sp,#-36]!0x0000281c<+8>: movs r4,#00x0000281e<+10>: strd r5, r6,[sp,#4]0x00002822<+14>: ldr.w r3,[pc,#3400] ; 0x356c <main+3416>0x00002826<+18>: movs r5,#20x00002828<+20>: strd r7, r8,[sp,#12]...(daisy-gdb) run Starting program:/bin/grep shebang /bin/ls qemu:Unsupported syscall:26#!/usr/bin/coreutils --coreutils-prog-shebang=ls qemu:Unsupported syscall:26During startup program exited normally.(daisy-gdb) quit

Note in the example above that, like “regular” gdb when given , you can pass the arguments for the program being debugged to the gdb wrapper script just by adding them to the command line after the name of the program being debugged (except that isn't needed).

The commands below show how to copy your incrementally-compiled unit test binary and source file(s) to the appropriate sysroot and then start gdb with that binary (using the correct libraries, etc).

(inside)(cr) $ cd /build/lumpy/tmp/portage (cr) $ mkdir shill-test (cr) $ cd shill-test (cr) $ cp <path-to-binary>/shill_unittest .(cr) $ cp <path-to-src>/ .(cr) $ gdb-lumpy (gdb-lumpy) directory /tmp/portage/shill-test # Tell gdb to add /tmp/portage/shill-test to the paths it searches for source files(gdb-lumpy) file ./shill_unittest

If gdb is still looking for the source file in the wrong directory path, you can use inside gdb to help it find the right path (inside your sysroot) for searching for source files.

Printing stack traces at runtime.

See ./ for how to print stack traces at runtime.

Remote Debugging

Setting up remote debugging by hand.

If you want to manually run through all the steps necessary to set up your system for remote debugging and start the debugger, see Remote Debugging in Chromium OS.

Automated remote debugging using gdb-${BOARD} script (gdb-lumpy, gdb-daisy, gdb-parrot, etc).

is a script that automates many of the steps necessary for setting up remote debugging with gdb. It should already be installed in your chroot. If you do not have the script, update your repository to get the latest changes, then re-build your packages:

(in/out) repo sync (inside)./build_packages --board=...

This should install in the directory inside the chroot. The script takes several options. The most important ones are mentioned below.

() are arguments to be passed to gdb itself (rather than to the program gdb is debugging). If multiple arguments are passed, each argument requires a separate -g flag.


is the ip_address or name for your chromebook, if you are doing remote debugging. If you omit this argument, the assumption is you are doing local debugging in the sysroot on your desktop (see section above). if you are debugging in the VM, then you need to specify either or .

is the pid of a running process on the remote device to which you want gdb/gdbserver to attach.

is the name of the running process on the remote device to which you want gdb/gdbserver to attach. If you want to attach to the Chrome browser itself, there are three special names you can use: will attach to the main browser process; will attach to the GPU process; and will attach to the renderer process if there is only one. If there is more than one renderer process will return a list of the renderer pids and stop.

To have gdb/gdbserver start and attach to a new (not already running) binary, give the name of the binary, followed by any arguments for the binary, at the end of the command line:

(inside) $ gdb-daisy --remote= "test"/tmp/myfile

When doing remote debugging you *must* use the or the option, or specify the name of a new binary to start. You cannot start a remote debugging session without having specified the program to debug in one of these three ways.

When you invoke , it will connect to the notebook or VM (automatically setting up port-forwarding on the VM), make sure the port is entered into the iptables, and start up gdbserver, using the correct port and binary, either attaching to the binary (if a remote pid or name was specified) or starting up the binary. It will also start the appropriate version of gdb (for whichever type of board you are debugging) on your desktop and connect the gdb on your desktop to the gdbserver on the remote device.

Edit/Debug cycle

If you want to edit code and debug it on the DUT you can follow this procedure

(inside) $ CFLAGS="-ggdb" FEATURES="noclean" emerge-${BOARD}-v sys-apps/mosys $ cros deploy --board=${BOARD} ${IP} sys-apps/mosys $ gdb-${BOARD}--cgdb --remote "${IP}" \ -g "--eval-command=directory /build/${BOARD}/tmp/portage/sys-apps/mosys-9999/work/" \ /usr/sbin/mosys -V

This will build your package with debug symbols (assuming your package respects ). We need to use the feature so that we have access to the original sourcecode that was used to build the package. Some packages will generate build artifacts and have different directory structures then the tar/git repo. This ensures all the paths line up correctly and the source code can be located. Ideally we would use the feature, but we don't have support for the debugedit package (yet!). Portage by default will strip the symbols and install the debug symbols in . will handle setting up the correct debug symbol path. cros deploy will then update the rootfs on the DUT. We pass the work directory into so that cgdb can display the sourcecode inline.

Quick primer on cgdb:

  • ESC: moves to the source window.
  • i: moves from source window to gdb window.

Examples of debugging using the gdb-${BOARD} script.

Below are three examples of using the board-specific gdb wrapper scripts to start up debugging sessions. The first two examples show connecting to a remote chromebook. The first one automatically finds the browser‘s running GPU process, attaches gdbserver to the running process, starts gdb on the desktop, and connects the local gdb to gdbserver. It also shows the user running the (backtrace) command after gdb comes up. The second example shows the user specifying the pid of a process on the chromebook. Again the script attaches gdbserver to the process, starts gdb on the desktop, and connects the two. The third example shows the user connecting to the main browser process in ChromeOS running in a VM on the user’s desktop. For debugging the VM, you can use either or ( gets translated into ).

Example 1:

(inside) $ gdb-lumpy --remote= 14:50:07: INFO: run: ping -c 1-w 20123.45.67.80914:50:09: INFO: run: file /build/lumpy/opt/google/chrome/chrome 14:50:10: INFO: run: x86_64-cros-linux-gnu-gdb --quiet '--eval-command=set sysroot /build/lumpy''--eval-command=set solib-absolute-prefix /build/lumpy''--eval-command=set solib-search-path /build/lumpy''--eval-command=set debug-file-directory /build/lumpy/usr/lib/debug''--eval-command=set prompt (lumpy-gdb) ''--eval-command=file /build/lumpy/opt/google/chrome/chrome''--eval-command=target remote localhost:38080'Reading symbols from /build/lumpy/opt/google/chrome/chrome...Reading symbols from/build/lumpy/usr/lib/debug/opt/google/chrome/chrome.debug...done.(lumpy-gdb) bt #0 0x00007f301fad56ad in poll () at ../sysdeps/unix/syscall-template.S:81#1 0x00007f3020d5787c in g_main_context_poll (priority=2147483647, n_fds=3, fds=0xdce10719840, timeout=-1, context=0xdce1070ddc0) at gmain.c:3584#2 g_main_context_iterate ([email protected]=0xdce1070ddc0,[email protected]=1, [email protected]=1, self=<optimized out>) at gmain.c:3285#3 0x00007f3020d5798c in g_main_context_iteration (context=0xdce1070ddc0may_block=1) at gmain.c:3351#4 0x00007f30226a4c1a in base::MessagePumpGlib::Run (this=0xdce10718580, delegate=<optimized out>) at ../../../../../chromeos-cache/distfiles/target/chrome-src-internal/src/base/message_loop/ 0x00007f30226666ef in base::RunLoop::Run ([email protected]=0x7fff72271af0) at ../../../../../chromeos-cache/distfiles/target/chrome-src-internal/src/base/ 0x00007f302264e165 in base::MessageLoop::Run ([email protected]=0x7fff72271db0) at ../../../../../chromeos-cache/distfiles/target/chrome-src-internal/src/base/message_loop/ 0x00007f30266bc847 in content::GpuMain (parameters=...) at ../../../../../chromeos-cache/distfiles/target/chrome-src-internal/src/content/gpu/ 0x00007f30225cedee in content::RunNamedProcessTypeMain (process_type=..., main_function_params=..., delegate=0x7fff72272380 at ../../../../../chromeos-cache/distfiles/target/chrome-src-internal/src/content/app/ 0x00007f30225cef3a in content::ContentMainRunnerImpl::Run (this=0xdce106fef50) at ../../../../../chromeos-cache/distfiles/target/chrome-src-internal/src/content/app/ 0x00007f30225cd551 in content::ContentMain (params=...) at ../../../../../chromeos-cache/distfiles/target/chrome-src-internal/src/content/app/ 0x00007f3021fef02a in ChromeMain (argc=21, argv=0x7fff722724b8) at ../../../../../chromeos-cache/distfiles/target/chrome-src-internal/src/chrome/app/ 0x00007f301fa0bf40 in __libc_start_main (main=0x7f3021fee760 <main(int, char const**)>, argc=21, argv=0x7fff722724b8, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>,stack_end=0x7fff722724a8) at libc-start.c:292#13 0x00007f3021feee95 in _start ()(lumpy-gdb)

Example 2:

(inside) $ gdb-daisy --pid=626--remote= INFO: run: ping -c 1-w 20123.45.98.76514:50:09: INFO: run: file /build/daisy/usr/sbin/cryptohomed 14:50:10: INFO: run: armv7a-cros-linux-gnueabi-gdb --quiet '--eval-command=set sysroot /build/daisy''--eval-command=set solib-absolute-prefix /build/daisy''--eval-command=set solib-search-path /build/daisy''--eval-command=set debug-file-directory /build/daisy/usr/lib/debug''--eval-command=set prompt (daisy-gdb) ''--eval-command=file /build/daisy/usr/sbin/cryptohomed''--eval-command=target remote localhost:38080'Reading symbols from /build/daisy/usr/sbin/cryptohomed...Reading symbols from/build/daisy/usr/lib/debug/usr/bin/cryptohomed.debug...done.(daisy-gdb)

Example 3:

(inside) $ gdb-lumpy --remote=:vm:--attach=browser 15:18:28: INFO: run: ping -c 1-w 20 localhost 15:18:31: INFO: run: file /build/lumpy/opt/google/chrome/chrome 15:18:33: INFO: run: x86_64-cros-linux-gnu-gdb --quiet '--eval-command=setsysroot /build/lumpy''--eval-command=set solib-absolute-prefix /build/lumpy''--eval-command=set solib-search-path /build/lumpy''--eval-command=set debug-file-directory /build/lumpy/usr/lib/debug''--eval-command=set prompt (lumpy-gdb) ''--eval-command=file /build/lumpy/opt/google/chrome/chrome''--eval-command=target remote localhost:48062'Reading symbols from /build/lumpy/opt/google/chrome/chrome...Reading symbols from /build/lumpy/usr/lib/debug/opt/google/chrome/chrome.debug...done.done.Remote debugging using localhost:48062...(lumpy-gdb)

If you find problems with the board-specific gdb scripts, please file a bug ( and add ‘build-toolchain’ as one of the labels in the bug.

Building Chrome for Chromium OS

See Simple Chrome Workflow.


I lost my developer tools on the stateful partition, can I get them back?

This happens sometimes because the security system likes to wipe out the stateful partition and a lot of developer tools are in /usr/local/bin. But all is not lost because there is a tool for updating the stateful partition from an image created by the auto-update part of the dev_server. Sadly, it is normally found in /usr/local so will have been lost too and you need to copy it over manually. This works for me:

$ cd /tmp $ scp [email protected]:/path/to/chromiumos/chroot/build/x86-whatever/usr/bin/stateful_update . $ sudo sh stateful_update $ sudo reboot

Note you can clobber the stateful partition (remove user accounts etc and force OOBE) as part of this process by using a flag:

$ cd /tmp $ scp [email protected]:/path/to/chromiumos/chroot/build/x86-whatever/usr/bin/stateful_update . $ sudo sh stateful_update --stateful_change=clean $ sudo reboot

Disabling Enterprise Enrollment

Some devices may be configured with a policy that only allows logging in with enterprise credentials, which will prevent you from logging in with a non-enterprise Google account (e.g., ). To disable the enterprise enrollment setting:

  • Enable Developer Mode.

  • Disable the enterprise enrollment check:

    (dut) $ vpd -i RW_VPD -check_enrollment=0(dut) $ dump_vpd_log --force (dut) $ crossystem clear_tpm_owner_request=1(dut) $ reboot

NOTE: The enterprise policy can also prevent transitioning to Developer Mode, in which case you won't be able to perform the above commands.

Running Tests

Chromium OS integration (or “functional”) tests are written using the Tast or Autotest frameworks.


Tast is a Go-based integration testing framework with a focus on speed, ease-of-use, and maintainability. Existing Autotest-based tests that run on the Chrome OS Commit Queue are being ported to Tast and decommissioned as of 2018 Q4. Please strongly consider using Tast when writing new integration tests (but be aware that not all functionality provided by Autotest is available in Tast; for example, tests that use multiple devices simultaneously when running are not currently supported).

Here are some starting points for learning more about Tast:

Please contact the public tast-users mailing list if you have questions.


Autotest is a Python-based integration testing framework; the codebase is also responsible for managing the Chrome OS lab that is used for hardware testing. Chromium-OS-specific Autotest information is available in the Autotest User Documentation.

Additional Autotest documentation:

Creating a normal image that has been modified for test

See Creating an image that has been modified for test for information about modifying a normal system image so that integration tests can be run on it.

Creating a VM image that has been modified for test

If you wish to produce a VM image instead, make sure to include the --test flag when running build_image and run with the --test_image flag:

(inside)./ --board=${BOARD}--test_image

Note: this difference between and arises because does not yet support the flag and by default looks for . We expect this to change in the future.

Creating a recovery image that has been modified for test

After building a test image using as described above, you may wish to encapsulate it within a recovery image:

(inside)./ \ --board=${BOARD} \ --nominimize_image \ --image ~/trunk/src/build/images/${BOARD}/latest/chromiumos_test_image.bin \ --to ~/trunk/src/build/images/${BOARD}/latest/recovery_test_image.bin

If desired, you may specify a custom kernel with .

You can write this recovery image out to the USB device like so:

(inside) cros flash usb://~/trunk/src/build/images/${BOARD}/latest/recovery_test_image.bin

Note that there are some downsides to this approach which you should keep in mind.

  • Your USB image will be a recovery mode/test image, but the ordinary image in your directory will be a non-test image.
  • If you use devserver, this will serve the non-test image not the test-image.
  • This means a machine installed with a test-enabled USB image will update to a non-test-enabled one.
  • As the boards set , recovery images built for don't work on devices with H1 chips (which requires ).

Additional information

Updating the chroot

You should run after . only updates the source code, is required to apply those changes to the chroot. can be run manually, alternatively it is run as part of and .


Toolchain Compilers

At any given time in the chroot, to see what cross-compiler version is the current default one, do:

  • For ARM:
  • For x86:
  • For amd64:

Sync to Green

Googlers/internal users may work from either the stable ref or from tip-of-tree (ToT) like external contributors; both are fully supported.

It‘s always the case that could sync to a broken tree in ChromeOS. There’s been many bug reports of this happening to folks over the years. There are two structural sources of this: chumped CL‘s and mutually incompatible CL’s landing at the same time.

If you have previously run without the , you can convert an existing checkout to stable:

(in/out) repo init -b stable repo sync

This stable ref is updated anytime that postsubmit-orchestrator passes all build and unit test stages (it ignores hardware tests so that the stables updates are more frequent). It should vary from 5-10 hours old, so long as ToT is not broken (which is rare).

You can continue to use master (switch back with ), if you prefer. You would want to do this if you want to see a change that just landed on ToT and don't want to wait for the stable ref to be updated to include the change you are interested in building off of. On the downside, master may be broken and may not have all binaries available, including Chrome (which typically takes 45 minutes to build).

We guarantee that binary prebuilt packages are available for everything at the stable ref including Chrome. Conversely, we don't guarantee Chrome binary prebuilts are available at ToT (they will be available there about 85% of the time). When building from stable, this should result in <10 min times in most cases.

In summary:

  • Stable pros: binaries always available; never broken
  • Stable cons: 5-10 hours old
  • Master pros: always has ToT changes
  • Master cons: more frequently broken, may need to build packages in the depgraph including Chrome which could add ~1 hours to build times

Attribution requirements

When you produce a Chromium OS image, you need to fulfill various attribution requirements of third party licenses. Currently, the images generated by a build don't do this for you automatically. You must modify about_os_credits.html.

Documentation on this site

You now understand the basics of building, running, modifying, and testing Chromium OS, but you've still got a lot to learn. Here are links to a few other pages on the site that you are likely to find helpful (somewhat ordered by relevance):

External documentation

Below are a few links to external sites that you might also find helpful (somewhat ordered by relevance):


Developer Information for Chrome OS Devices


This page provides developer-related information for Chrome devices.  These are systems that shipped from the factory with Google Chrome OS on them.  For details about Google Chrome OS and how it differs from Chromium OS, see the note in the FAQ about Google Chrome OS.  Chrome OS devices typically require special setup in order to be used for Chromium OS development.

Caution: Modifications you make to the system are not supported by Google, may cause hardware, software or security issues and may void warranty.

Remember: Chrome OS devices are not general-purpose PCs.  We believe you should be able to hack on your own property, but if you do it's not our fault if something breaks.

Googlers not finding what they're looking for may want to look at go/cros-names.

End of Life (EOL) / Auto Update Expiration (AUE)

The official Google policy includes projected dates. Here we focus on the corresponding release versions as that is often more useful to developers.


These WiFi routers are marketed as OnHub, Google Wifi, and Nest Wifi.

Release date Manufacturer Model Project code name Board name(s)Base board
 August 2015 TP-LINKOnHub Router TGR1900 Whirlwind whirlwind storm
 November 2015 ASUS OnHub SRT-AC1900 Arkham arkham storm
 November 2016 GoogleGoogle WiFi Gale gale gale
 November 2019 GoogleNest Wifi router (not "point") Mistral mistral mistral

USB Type-C

Notebooks and Desktops

These are your standard Chromebook/Chromebox/etc devices.

ReleaseOEMModelCode nameBoard name(s)Base boardUser ABIKernelKernel ABIPlatformForm FactorFirst ReleaseEOL/AUEUSB GadgetClosed Case Debugging
Google Pixelbook Goatlas atlas poppy x86_64 4.4 x86_64 Amberlake-Y Chromebook M75 June 2026 Yes Yes 
Lenovo IdeaPad Flex 5i Chromebooklillipup volteer volteer x86_64 5.4 x86_64 TigerLake-UP3 Chromebook R90 June 2029 Yes 
Lenovo Lenovo 300e Chromebook Gen 3 AMDvilboz360 zork dalboz x86_64 5.4 x86_64 Pollock Chromebook R91 
Lenovo Lenovo 100e Chromebook Gen 3 AMDvilboz zork dalboz x86_64 5.4 x86_64 Pollock Chromebook M91 
Acer Acer Chromebook 712Kindred Hatch  Hatch x86_64 4.19 x86_64 Cometlake-U Chromebook R79 Yes 
Asus  ASUS Chromebook Detachable CM3 (CM3000)Kakadu kukui kukui arm 4.19 aarch64 MT8183 Chromeblet R88 Yes 
HP Blooguard octopus octopus x86_64 4.14 x86_64 Gemini Lake Convertible 06/2026 
Asus ASUS Chromebook Flip CM3 (CM3200)Damu jacuzzi jacuzzi arm 4.19 aarch64 MT8183 Convertible R87 Yes 
Lenovo IdeaPad Flex 5i Chromebook (13", 5) Akemi Hatch Hatch  x86_64 4.19 x86_64 Cometlake-U Convertible R81 Yes 
December 5, 2010 Google Cr-48Mario x86-mario x86 3.8 x86 PineTrail Chromebook ~R8 R56 No 
May 30, 2011 Samsung Samsung Series 5 ChromebookAlex x86-alex & x86-alex_he x86 3.8 x86 PineTrail Chromebook R11 R58 No 
June 30, 2011 Acer Acer AC700 ChromebookZGB x86-zgb & x86-zgb_he x86 3.8 x86 PineTrail Chromebook R12 R58 No 
April 29, 2012 Samsung Samsung Chromebook Series 5 550Lumpy lumpy x86_64 3.8 x86_64 SandyBridge Chromebook R17 R65 No  
July 1, 2012 Samsung Samsung Chromebox Series 3Stumpy stumpy x86_64 3.8 x86_64 SandyBridge Chromebox R17 R65 No 
October 14, 2012 Samsung Samsung ChromebookSnow daisy daisy arm 3.8 arm Exynos 5250 Chromebook R22 R75 No  
October 30, 2012 Acer Acer C7 ChromebookParrot parrot_ivb parrot x86_64 3.8 x86_64 IvyBridge Chromebook R27 R69 No 
October 30, 2012 Acer Acer C7 ChromebookParrot parrot x86_64 3.8 x86_64 SandyBridge Chromebook R21 R65 No 
December 30, 2012 Lenovo Lenovo Thinkpad X131e ChromebookStout stout x86_64 3.8 x86_64 IvyBridge Chromebook R22 R69 No 
January 30, 2013 Google Google Chromebook PixelLink link x86_64 3.8 x86_64 IvyBridge Chromebook R22 R69 No 
January 30, 2013 HP HP Pavilion Chromebook 14Butterfly butterfly x86_64 3.8 x86_64 SandyBridge Chromebook R22 R65 No 
September 12, 2013 Acer Acer C720/C70P/C740 ChromebookPeppy & Pepto peppy slippy x86_64 3.8 x86_64 Haswell Chromebook R30 R76 No 
September 29, 2013 HP HP Chromebook 14Falco falco & falco_li slippy x86_64 3.8 x86_64 Haswell Chromebook R30 R76 No 
September 29, 2013 HP HP Chromebook 11 G1Spring daisy_spring snow arm 3.8 arm Exynos 5250 Chromebook R27 R72 No 
January 15, 2014 Dell Dell Chromebook 11Wolf wolf slippy x86_64 3.8 x86_64 Haswell Chromebook R31 R76 No 
January 30, 2014 Toshiba Toshiba ChromebookLeon leon slippy x86_64 3.8 x86_64 Haswell Chromebook R31 R76 No 
March 13, 2014 ASUS ASUS Chromebox CN60Panther panther beltino x86_64 3.8 x86_64 Haswell Chromebox R32 R76 No 
May 4, 2014 Samsung Samsung Chromebook 2 11"Pit peach_pit peach arm 3.8 arm Exynos 5450 Chromebook R30 R75 No 
May 18, 2014 Samsung Samsung Chromebook 2 13"Pi peach_pi peach arm 3.8 arm Exynos 5450 Chromebook R34 R75 No 
May 18, 2014 LG LG Chromebase 22CV241 & 22CB25SMonroe monroe beltino x86_64 3.8 x86_64 Haswell Chromebase R33 No 
May 25, 2014 HP HP Chromebook 11 G2Skate daisy_skate snow arm 3.8 arm Exynos 5250 Chromebook R34 R75 No 
May 29, 2014 Lenovo Lenovo N20 ChromebookClapper clapper rambi x86_64 4.4 x86_64 BayTrail Convertible R34 R76 No 
May 31, 2014 ASUS ASUS Chromebook C200Squawks squawks rambi x86_64 4.4 x86_64 BayTrail Chromebook R34 R76 No 
June 5, 2014 Lenovo Lenovo ThinkPad 11e ChromebookGlimmer glimmer rambi x86_64 4.4 x86_64 BayTrail Convertible R34 R76 No 
June 14, 2014 <white label> Enguarde enguarde rambi x86_64 4.4 x86_64 BayTrail Chromebook R34 No 
June 14, 2014 <white label> Expresso expresso rambi x86_64 4.4 x86_64 BayTrail Chromebook R34 No 
June 21, 2014 HP HP Chromebox G1Zako zako beltino x86_64 3.8 x86_64 Haswell Chromebox R34 R76 No 
August 20, 2014 Acer Acer ChromeboxMcCloud mccloud beltino x86_64 3.8 x86_64 Haswell Chromebox R36 R76 No 
August 30, 2014 ASUS ASUS Chromebook C300Quawks quawks rambi x86_64 4.4 x86_64 BayTrail Chromebook R34 R76 No 
August 31, 2014 Acer Acer Chromebook 11 (C730 / C730E / C735)Gnawty gnawty rambi x86_64 4.4 x86_64 BayTrail Chromebook R34 No 
September 1, 2014 HP HP Chromebook 11 G3 / G4 / G4 EEKip kip rambi x86_64 4.4 x86_64 BayTrail Chromebook R34 No 
September 2, 2014 Toshiba Toshiba Chromebook 2Swanky swanky rambi x86_64 4.4 x86_64 BayTrail Chromebook R36 No 
September 7, 2014 Acer Acer Chromebook 13 (CB5-311)Big nyan_big nyan arm 3.10 arm Tegra K1 T124 Chromebook R35 R77 No 
September 13, 2014 Dell Dell ChromeboxTricky tricky beltino x86_64 3.8 x86_64 Haswell Chromebox R36 R76 No 
October 13, 2014 Samsung Samsung Chromebook 2 11 - XE500C12Winky winky rambi x86_64 4.4 x86_64 BayTrail Chromebook R36 No 
October 18, 2014 HP HP Chromebook 14 G3Blaze nyan_blaze nyan arm 3.10 arm Tegra K1 T124 Chromebook R36 R77 No 
February 28, 2015 Acer Acer C670 Chromebook 11Paine auron_paine auron x86_64 3.14 x86_64 Broadwell Chromebook R40 
February 28, 2015 Dell Dell Chromebook 11 (3120)Candy candy rambi x86_64 4.4 x86_64 BayTrail Chromebook R39 No 
March 11, 2015 Google Google Chromebook Pixel (2015)Samus samus x86_64 4.14 x86_64 Broadwell Chromebook R39 
April 23, 2015 Acer Acer Chromebook 15.6" (CB3-531)Banjo banjo rambi x86_64 4.4 x86_64 BayTrail Chromebook R42 No 
April 30, 2015 <white label> Jaq veyron_jaq veyron_pinky arm 4.19 arm RK3288 Chromebook R41 
April 30, 2015 <white label> Mighty veyron_mighty veyron_pinky arm 4.19 arm RK3288 Chromebook R41 
April 30, 2015 Acer Acer Chromebook 15Yuna auron_yuna auron x86_64 3.14 x86_64 Broadwell Chromebook R40 
April 30, 2015 <white label> Jerry veyron_jerry veyron_pinky arm 4.19 arm RK3288 Chromebook R41 
May 1, 2015 ASUS ASUS Chromebook C201Speedy veyron_speedy veyron_pinky arm 4.19 arm RK3288 Chromebook R41 
May 1, 2015 Acer Acer Chromebox CXI2Rikku rikku jecht x86_64 3.14 x86_64 Broadwell Chromebox R42 
June 2, 2015 Lenovo Lenovo ThinkCentre ChromeboxTidus tidus jecht x86_64 3.14 x86_64 Broadwell Chromebox R42 
July 1, 2015 ASUS ASUS Chromebook Flip C100PAMinnie veyron_minnie veyron_pinky arm 4.19 arm RK3288 Convertible R42 
August 1, 2015 Acer Acer ChromebaseKitty nyan_kitty nyan arm 3.10 arm Tegra K1 T124 Chromebase R40 No 
August 3, 2015 ASUS ASUS Chromebox CN62Guado guado jecht x86_64 3.14 x86_64 Broadwell Chromebox R41 
August 13, 2015 Dell Dell Chromebook 13 7310Lulu lulu auron x86_64 3.14 x86_64 Broadwell Chromebook R43 
September 1, 2015 AOpen AOpen Chromebox CommercialNinja ninja rambi x86_64 4.4 x86_64 BayTrail Chromebox R43 No 
September 2, 2015 AOpen AOpen Chromebase CommercialSumo sumo rambi x86_64 4.4 x86_64 BayTrail Chromebase R43 No 
September 4, 2015 Lenovo Lenovo 100S ChromebookOrco orco rambi x86_64 4.4 x86_64 BayTrail Chromebook R44 No 
September 22, 2015 Toshiba Toshiba Chromebook 2 (2015 Edition)Gandof gandof auron x86_64 3.14 x86_64 Broadwell Chromebook R44 
November 2, 2015 ASUS Asus Chromebit CS10Mickey veyron_mickey veyron_pinky arm 4.19 arm RK3288 Chromebit R45 
November 26, 2015 <white label> Heli heli rambi x86_64 4.4 x86_64 BayTrail Chromebook R45 No 
December 1, 2015 Acer Acer Chromebook R11Cyan cyan strago x86_64 3.18 x86_64 Braswell Chromebook R44 
December 22, 2015 Samsung Samsung Chromebook 3Celes celes strago x86_64 3.18 x86_64 Braswell Chromebook R46 
February 29, 2016 ASUS ASUS Chromebook C202SA/C300SATerra terra strago x86_64 3.18 x86_64 Braswell Chromebook R48 
March 7, 2016 Lenovo ThinkPad 11e Chromebook 3rdUltima ultima strago x86_64 3.18 x86_64 Braswell Chromebook R48 
March 29, 2016 Acer Chromebook 14 (CB3-431)Edgar edgar strago x86_64 3.18 x86_64 Braswell Chromebook R49 
April 1, 2016 Acer Acer Chromebase 24Buddy buddy auron x86_64 3.14 x86_64 Broadwell Chromebase R48 
May 5, 2016 HP HP Chromebook 13 G1Chell chell glados x86_64 3.18 x86_64 Skylake Chromebook R49 
May 27, 2016 Lenovo Thinkpad 13 ChromebookSentry sentry kunimitsu x86_64 3.18 x86_64 Skylake Chromebook R50 
May 31, 2016 Acer Chromebook 14 for work (CP5-471)Lars lars kunimitsu x86_64 3.18 x86_64 Skylake Chromebook R49 
July 8, 2016 HP HP Chromebook 11 G5Setzer setzer strago x86_64 3.18 x86_64 Braswell Chromebook R51 
August 1, 2016 Lenovo Lenovo Chromebook 11Reks reks strago x86_64 3.18 x86_64 Braswell Chromebook R48 
August 5, 2016 <white label> Relm relm strago x86_64 3.18 x86_64 Braswell Chromebook R52 
August 8, 2016 <white label> Wizpig wizpig strago x86_64 3.18 x86_64 Braswell Convertible R50 
August 12, 2016 Acer Acer 15.6" ChromebookBanon banon strago x86_64 3.18 x86_64 Braswell Chromebook R51 
September 6, 2016 Acer Acer Chromebook R13Elm elm oak arm 3.18 aarch64 MT8173 Convertible R52 
January 5, 2017 ASUS ASUS Chromebook Flip C302Cave cave glados x86_64 3.18 x86_64 Skylake Convertible R53 
February 7, 2017 Dell Chromebook 11 Model 3180Kefka kefka strago x86_64 3.18 x86_64 Braswell Chromebook R54 
February 7, 2017 Dell Dell Chromebook 13 3380Asuka asuka kunimitsu x86_64 3.18 x86_64 Skylake Chromebook R55 
February 12, 2017 Samsung Samsung Chromebook PlusKevin kevin gru arm 4.4 aarch64 RK3399 Convertible R53 
February 28, 2017 AOpen AOpen Chromebase Minitiger veyron_tiger veyron_pinky arm 4.19 arm RK3288 Chromebase R54 
February 28, 2017 AOpen AOpen Chromebox Minifievel veyron_fievel veyron_pinky arm 4.19 arm RK3288 Chromebox R54 
March 17, 2017 Lenovo Lenovo N23 Yoga Chromebookhana hana oak arm 3.18 aarch64 MT8173 Convertible R56 
April 24, 2017 Lenovo Lenovo Thinkpad 11e Chromebook / Lenovo Thinkpad Yoga 11e ChromebookPyro pyro reef x86_64 4.4 x86_64 ApolloLake Chromebook R56 Yes 
April 24, 2017 HP HP Chromebook x360 11 G1 EESnappy snappy reef x86_64 4.4 x86_64 ApolloLake Convertible R56 Yes 
May 25, 2017 Samsung Samsung Chromebook ProCaroline caroline glados x86_64 3.18 x86_64 Skylake Convertible R56 
June 30, 2017 Acer Acer Chromebook Spin 11 R751TElectro reef reef x86_64 4.4 x86_64 ApolloLake Chromebook R53 Yes 
August 10, 2017 Poin2 Poin2 Chromebook 14Birch hana oak arm 3.18 aarch64 MT8173 Chromebook R56 
September 1, 2017 ASUS Asus Chromebook Flip C101PABob Bob gru arm 4.4 aarch64 RK3399 Convertible R58 Hinge Port 
September 8, 2017 Acer Chromebook 15 CB515-1HT/1HSand sand reef x86_64 4.4 x86_64 ApolloLake Chromebook R59 Yes 
October 31, 2017 Google PixelbookEve eve eve x86_64 4.4 x86_64 Kabylake-Y Convertible R61 Left Port Left Port 
November 15, 2017 Poin2 Poin2 Chromebook 11CHanawl hana oak arm 3.18 aarch64 MT8173 Chromebook R56 
February 14, 2018 Acer Acer Chromebook 11 (C732, C732T, C732L & C732LT )Astronaut coral coral x86_64 4.4 x86_64 ApolloLake Chromebook R64 Yes 
March 1, 2018 Lenovo Lenovo 300e Chromebookhana hana oak arm 3.18 aarch64 MT8173 Convertible R64 
March 1, 2018 Lenovo Lenovo 100e Chromebookrobo coral coral x86_64 4.4 x86_64 ApolloLake Chromebook R64 Yes 
March 1, 2018 Lenovo Lenovo 500e Chromebookrobo360 coral coral x86_64 4.4 x86_64 ApolloLake Convertible R64 Yes 
March 5, 2018 Acer AcerChromebook 11 (CB311-8H & CB311-8HT)Santa coral coral x86_64 4.4 x86_64 ApolloLake Chromebook R64 Yes 
March 16, 2018 Acer Acer Chromebook Spin 11 (CP311-1H & CP311-1HN)Lava coral coral x86_64 4.4 x86_64 ApolloLake Convertible R64 Yes 
May 18, 2018 HP HP Chromebox G2Kench fizz fizz x86_64 4.4 x86_64 Kabylake-U/R Chromebox Yes 
June 1, 2018 Acer Acer Chromebox CXI3Sion fizz fizz x86_64 4.4 x86_64 Kabylake-U/R Chromebox Yes 
June 1, 2018 CTL CTL Chromebox CBx1Wukong fizz fizz x86_64 4.4 x86_64 Kabylake-U/R Chromebox R67 
June 1, 2018 Viewsonic ViewSonic NMP660 ChromeboxWukong fizz fizz x86_64 4.4 x86_64 Kabylake-U/R Chromebox Yes 
June 1, 2018 HP HP Chromebook x2Soraka soraka poppy x86_64 4.4 x86_64 Kabylake-Y Chromeblet Left Port Yes 
June 1, 2018 ASUS ASUS Chromebox 3Teemo fizz fizz x86_64 4.4 x86_64 Kabylake-U/R Chromebox Yes 
June 14, 2018 Samsung Samsung Chromebook Plus (V2)Nautilus nautilus poppy x86_64 4.4 x86_64 Kabylake-Y Convertible R67 Yes 
June 15, 2018 CTL CTL Chromebook J41Whitetip coral coral x86_64 4.4 x86_64 ApolloLake Chromebook R67 
June 30, 2018 CTL CTL Chromebook NL7Blacktip coral coral x86_64 4.4 x86_64 ApolloLake Chromebook R67 
June 30, 2018 CTL CTL Chromebook NL7T-360Blacktip360 coral coral x86_64 4.4 x86_64 ApolloLake Convertible R67 
June 30, 2018 <white label> blacktip coral coral x86_64 4.4 x86_64 ApolloLake Chromebook R67 Yes 
August 8, 2018 ASUS ASUS Chromebook C223babymega coral coral x86_64 4.4 x86_64 ApolloLake Chromebook R67 yes 
August 31, 2018 Lenovo Lenovo Chromebook C330maple hana oak arm 3.18 aarch64 MT8173 Convertible R67 
September 14, 2018 ASUS ASUS Chromebook C423rabbid coral coral x86_64 4.4 x86_64 ApolloLake Chromebook R68 yes 
September 17, 2018 Lenovo Lenovo Chromebook S330maple14 hana oak arm 3.18 aarch64 MT8173 Chromebook M67 
October 8, 2018 ASUS ASUS Chromebook C523babytiger coral coral x86_64 4.4 x86_64 ApolloLake Chromebook R69 yes 
October 15, 2018 Acer Epaulette coral coral x86_64 4.4 x86_64 ApolloLake Chromebook R69 Yes 
October 26, 2018 Dell Dell Inspiron 14 2-in-1 Model 7486vayne vayne nami x86_64 4.4 x86_64 Kabylake-U/R Chromebook R69 Yes 
October 26, 2018 Lenovo Yoga Chromebook C630pantheon pantheon nami x86_64 4.4 x86_64 Kabylake-U/R Convertible R69 Yes 
October 26, 2018 Acer Acer Chromebook 13 / Spin 13Akali / Akali360 nami nami x86_64 4.4 x86_64 Kabylake-U/R Convertible R69 
November 2, 2018 Samsung Samsung Chromebook Plus LTENautilus LTE nautilus poppy x86_64 4.4 x86_64 Kabylake-Y Convertible R69 yes 
November 26, 2018 Google Google Pixel SlateNocturne nocturne poppy x86_64 4.4 x86_64 Kabylake-Y Chromeblet R71 Left Port Left Port 
January 6, 2019 HP HP Chromebook 14 (db0000-db0999)careena grunt grunt x86_64 4.14 x86_64 Stoney Ridge Chromebook R70 Right Port 
January 7, 2019 Acer Acer Chromebook 315Aleena grunt grunt x86_64 4.14 x86_64 Stoney Ridge Chromebook R71 Left Port 
January 16, 2019 PCmerge PCmerge Chromebook AL116Whitetip coral coral x86_64 4.4 x86_64 ApolloLake Chromebook R71 yes 
January 18, 2019 ASUS ASUS Chromebook C403babymako coral coral x86_64 4.4 x86_64 ApolloLake Chromebook R71 yes 
January 21, 2019 HP HP Chromebook 11A G6 EEBarla grunt grunt x86_64 4.14 x86_64 Stoney Ridge Chromebook R71 Right Port 
February 27, 2019 Lenovo Lenovo 300e Chromebook 2nd Gen (MTK)Sycamore360 hana oak arm 3.18 aarch64 MT8173 Chromebook R72 
February 27, 2019 Acer Acer Chromebook 311bobba bobba octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R72 Yes 
February 27, 2019 Acer Acer Chromebook Spin 511bobba360 bobba360 octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R72 Yes 
February 27, 2019 Lenovo Lenovo 100e Chromebook 2nd Gen (MTK)Sycamore hana oak arm 3.18 aarch64 MT8173 Chromebook R72 
March 1, 2019 Lenovo Lenovo 300e Chromebook 2nd Gen (Intel)Phaser360 Octopus octopus x86_64 4.14 x86_64 Gemini Lake Convertible R72 Yes 
March 1, 2019 Lenovo Lenovo 100e Chromebook 2nd Gen (Intel)Phaser Octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R72 Yes 
March 1, 2019 Lenovo Lenovo 500e Chromebook 2nd GenPhaser360S Octopus x86_64 4.14 x86_64 Gemini Lake Convertible R72 Yes 
March 6, 2019 Acer Acer Chromebook Spin 512(R851TN)sparky360 octopus octopus x86_64 4.14 x86_64 Gemini Lake Convertible R72 yes 
March 6, 2019 Lenovo Lenovo 14e Chromebookliara liara grunt x86_64 4.14 x86_64 Stoney Ridge Chromebook R71 Left Port 
March 8, 2019 Acer Acer Chromebook 512(C851/C851T)sparky octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R72 yes 
March 15, 2019 ASUS ASUS Chromebook Flip C434Shyvana rammus rammus x86_64 4.4 x86_64 Amberlake-Y Convertible R72 yes 
March 22, 2019 Acer The Acer Chromebook 311 (C721) Kasumi grunt grunt x86_64 4.14 x86_64 Stoney Ridge Chromebook R72 Left Port 
March 22, 2019 Acer Acer Chromebook Spin 311 (R721T)Kasumi360 grunt grunt x86_64 4.14 x86_64 Stoney Ridge Chromebook R72 Left Port 
March 30, 2019 ASUS ASUS Chromebook Tablet CT100Dumo scarlet scarlet arm 4.4 aarch64 RK3399 Chromeblet R73 
April 1, 2019 CTL CTL Chromebook Tab Tx1Druwl scarlet scarlet arm 4.4 aarch64 RK3399 Chromeblet R72 
April 5, 2019 ASUS ASUS Chromebook Flip C204Apel octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R73 yes 
April 5, 2019 ASUS ASUS-Chromebook-Flip-C214Ampton octopus octopus x86_64 4.14 x86_64 Gemini Lake Convertible R73 yes 
April 22, 2019 HP HP Chromebook x360 11 G2 EEMeep octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R73 Yes 
April 22, 2019 HP HP Chromebook 11 G7 EEMimrock octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R73 Yes 
June 17, 2019 Lenovo  Lenovo Chromebook C340-11Laser octopus octopus x86_64 4.14 x86_64 Gemini Lake Convertible R74 yes 
June 17, 2019 Lenovo Lenovo Chromebook S340-14Laser14 octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R74 yes 
July 31, 2019 Lenovo Lenovo Chromebook C340-15pyke nami nami x86_64 4.4 x86_64 Kabylake-U/R Convertible M75 Yes 
August 20, 2019 ASUS ASUS Chromebook C425leona leona rammus x86_64 4.4 x86_64 Amberlake-Y Chromebook M75 Yes 
August 26, 2019 Dell Dell Latitude 5400 Chromebook Enterprisesarien sarien sarien x86_64 4.19 x86_64 Whiskey Lake Chromebook R75 No 
August 26, 2019 Dell Latitude 5300 2-in-1 Chromebook Enterprisearcada sarien sarien x86_64 4.19 x86_64 Whiskey Lake Chromebook R75 No 
September 2, 2019 ASUS ASUS Chromebook Flip C433TAshyvana-m shyvana rammus x86_64 4.4 x86_64 Amberlake-Y Convertible M75 Yes 
September 4, 2019 Acer Acer Chromebook 315 (CB315-3H/3HT)Blorb octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R76 Yes 
September 4, 2019 Acer Acer Chromebook 314 (CB314-1H/1HT)Droid octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R76 Yes 
September 4, 2019 Acer Acer Chromebook Spin 311 (CP311-2H)gik360 octopus octopus x86_64 4.14 x86_64 Gemini Lake Convertible R76 Yes 
September 4, 2019 Acer Acer Chromebook 311 (CB311-9HT/9H) )gik octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R76 Yes 
October 7, 2019 Samsung Samsung Chromebook 4Bluebird octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebox R76 yes 
October 7, 2019 Samsung Samsung Chromebook+Casta octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook M75 yes 
October 15, 2019 Google Pixelbook Goatlas atlas poppy x86_64 4.4 x86_64 Amberlake-Y Chromebook October 2019 June 2026 Yes Yes 
December 27, 2019 ASUS ASUS Chromebook C202XAtelesu hana hana arm 3.18 aarch64 MT8173 Chromebook M78 
January 6, 2020 Samsung Samsung Galaxy Chromebookkohaku hatch hatch x86_64 4.19 x86_64 Cometlake-U Convertible M79 Yes 
January 7, 2020 Lenovo Lenovo Chromebook Duet/Lenovo IdeaPad Duet Chromebookkrane kukui kukui arm 4.19 aarch64 MT8183 Chromeblet R79 Yes 
January 13, 2020 ASUS ASUS Chromebook Flip C436FAhelios hatch hatch x86_64 4.19 x86_64 Cometlake-U Convertible M79 Yes 
January 14, 2020 Lenovo Lenovo 10e Chromebook Tabletkodama kukui kukui arm 4.19 aarch64 MT8183 Chromeblet M80 Yes 
January 20, 2020 HP HP Chromebook x360 11 G3 EEVortininja octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R78 
January 20, 2020 HP HP Chromebook 14 G6Dorp octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R78 
January 20, 2020 HP HP Chromebook 11 G8 EEVorticon octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R78 
February 28, 2020 HP HP Chromebook 14ablooglet octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R79 
February 28, 2020 Lenovo Lenovo 100e 2nd Gen AMDTreeya Grunt x86_64 4.14 x86_64 Stoney Ridge Chromebook R80 
February 28, 2020 Lenovo Lenovo 300e 2nd Gen AMDTreeya360 Grunt x86_64 4.14 x86_64 Stoney Ridge Convertible R80 
May 1, 2020 Acer Acer Chromebook 314 (C933L/LT)droid octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R80 Yes 
June 23, 2020 Acer Acer Chromebook Spin 311 (CP311-3H)juniper jacuzzi jacuzzi arm 4.19 aarch64 MT8183 Chromebook M81 Yes 
July 31, 2020 Lenovo Ideapad 3 ChromebookLick Octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R80 
August 11, 2020 Dell Dell Latitude 7410 Chromebook EnterpriseDrallion Drallion Drallion x86_64 4.19 x86_64 Cometlake-U Chromebook R83 Yes 
October 12, 2020 Lenovo Lenovo ThinkPad C13 Yoga Chromebookmorphius zork zork x86_64 5.4 x86_64 Picasso/Dali Convertible M86 Yes 
October 23, 2020 HP HP Chromebox G3Noibat Puff Puff x86_64 4.19 x86_64 Cometlake-U Chromebox R85 Yes 
October 29, 2020 ASUS ASUS Chromebox 4Duffy Puff Puff x86_64 4.19 x86_64 Cometlake-U Chromebox R85 Yes 
October 29, 2020 Acer Acer Chromebox CXI4Kaisa Puff Puff x86_64 4.19 x86_64 Cometlake-U Chromebox R85 Yes 
November 13, 2020 ASUS ASUS Fanless ChromeboxFaffy Puff Puff x86_64 4.19 x86_64 Cometlake-U Chromebox R85 Yes 
December 29, 2020 HP HP Pro c645 Chromebook Enterpriseberknip zork zork x86_64 5.4 x86_64 Picasso/Dali Chromebook M86 June 2029 Yes 
January 7, 2021 Samsung Samsung Galaxy Chromebook 2nightfury hatch hatch x86_64 4.19 x86_64 Cometlake-U Convertible Yes 
January 13, 2021 Acer Acer Chromebook Spin 514Ezkinil Zork Zork x86_64 4.19 x86_64 Picasso/Dali Convertible R86 Yes 
January 22, 2021 Acer Acer Chromebook Spin 513Lazor Trogdor Trogdor arm 5.4 aarch64 QC-7C Convertible R87 Yes 
January 29, 2021 HP HP Chromebook 11MK G9 EEesche jacuzzi jacuzzi arm 4.19 aarch64 MT8183 Chromebook R87 Yes 
January 29, 2021 HP HP Chromebook x360 11MK G3 EEburnet jacuzzi jacuzzi arm 4.19 aarch64 MT8183 Convertible R87 Yes 
March 5, 2021 HP HP Chromebook 14 G7Drawman Dedede Dedede x86_64 5.4 x86_64 Jasper Lake Chromebook R87 June 2029 Yes 
March 12, 2021 HP HP Chromebook 11 G9 EEDrawlat Dedede Dedede x86_64 5.4 x86_64 Jasper Lake Chromebook R87 June 2029 Yes 
March 19, 2021 HP HP Chromebook x360 11 G4 EEDrawcia Dedede Dedede x86_64 5.4 x86_64 Jasper Lake Chromebook R88 June 2029 Yes 
March 26, 2021 HP HP Chromebook 14a-nd0097nrdirinboz zork dalboz x86_64 5.4 x86_64 Pollock Chromebook R88 June 2029 Yes 
April 16, 2021 Asus ASUS Chromebook Flip CM5woomax zork zork x86_64 5.4 x86_64 Picasso/Dali Chromebook R88 June 2029 Yes 
May 25, 2021 Lenovo Lenovo 500e Chromebook Gen 3Boten boten dedede x86_64 5.4 x86_64 Jasper Lake Convertible R90 June 2029 Yes 
May 27, 2021 Acer Acer Chromebook Spin 713 (CP713-3W)Voxel Volteer Volteer x86_64 5.4 x86_64 TigerLake-UP3 Convertible R89 Jun 2029  Yes 
May 27, 2021 Acer The Acer Chromebook 514 (CB514-1H)Volta Volteer Volteer x86_64 5.4 x86_64 TigerLake-UP3 Chromebook R91 June 2029 Yes 
May 30, 2021 Lenovo botenflex boten dedede x86_64 5.4 x86_64 Jasper Lake Chromebook R90 June 2029 Yes 
May 31, 2021 Asus ASUS Chromebook Flip CX5 (CX5500)delbin Volteer Volteer x86_64 5.4 x86_64 TigerLake-UP3 Convertible R89 June 2029 Yes 
June 4, 2021 HP  HP Pro c640 G2 ChromebookElemi Volteer Volteer x86_64 5.4 x86_64 TigerLake-UP3 Chromebook R90 June 2029 Yes 
June 16, 2021 HP HP Chromebook 14aLantis Dedede Dedede x86_64 5.4 x86_64 Jasper Lake Chromebook R90 June 2029 Yes 
June 26, 2021 Asus copano copano terrador x86_64 5.4 x86_64 TigerLake-UP4 Chromebook R90 June 2029 Yes 
June 30, 2021 Acer Acer Chromebook 511Limozeen Trogdor Trogdor arm 5.4 aarch64 QC-7C Chromebook R90 June 2029 Yes 
July 7, 2021 HP HP Chromebook x360 14aGumboz zork dalboz x86_64 5.4 x86_64 Pollock Chromebook R89 July 2029 Yes 
July 20, 2021 Asus ASUS Chromebook CX9 (CX9400)drobit drobit Volteer x86_64 5.4 x86_64 TigerLake-UP3 Chromebook R90 June 2029 Yes 
August 2, 2021 Asus Asus Chromebook CX1500Galith Dedede Dedede x86_64 5.4 x86_64 Jasper Lake Chromebook R90 June 2029 Yes 
August 5, 2021 Samsung Galaxy Chromebook Gosasuke sasuke dedede x86_64 5.4 x86_64 Jasper Lake Chromebook R90 June 2029 Yes 
August 20, 2021 ASUS ASUS Chromebook CX1101Apele octopus octopus x86_64 4.14 x86_64 Gemini Lake Chromebook R91 June 2026 Yes 
August 21, 2021 ASUS ASUS Chromebook C424Nospike Octopus Octopus x86_64 4.14 x86_64 Gemini Lake Chromebook M75 June 2026 
August 23, 2021 ASUS ASUS Chromebook Flip CM1Jelboz360 zork dalboz x86_64 5.4 x86_64 Pollock Chromebook R92 June 2029 Yes 
August 24, 2021 Asus ASUS Chromebook CX1700Gallop Dedede Dedede x86_64 5.4 x86_64 Jasper Lake Chromebook R91 June 2029 Yes 
September 23, 2021 Lenovo Lenovo Chromebook Duet 5 /IdeaPad Duet 5 ChromebookHomestar Strongbad Strongbad arm 5.4 aarch64 QC-7C Chromeblet R92 June 2029 Yes 
September 27, 2021 Asus ASUS Chromebook Flip CR1100Storo360 Dedede Dedede x86_64 5.4 x86_64 Jasper Lake Convertible R92 June 2029 Yes 
September 27, 2021 Asus ASUS Chromebook CR1100Storo Dedede Dedede x86_64 5.4 x86_64 Jasper Lake Chromebook R92 June 2029 Yes 
October 14, 2021 Acer Acer Chromebook 514Spherion asurada asurada arm 5.4 aarch64 MT8183 Chromebook M93 June 2029 
  1. Definition of voraciously
  2. International dt466 thermostat
  3. Everton transfers
  4. Treasures ffxv

Developer Mode

Warning: This document is old & has moved. Please update any links:

Production Chrome OS devices that are shipped from the factory are locked down and will not let you make changes to the software. This page describes how to enable developer mode and get root access to your system.

Enable Developer Mode

Modern Chrome OS devices can be put into developer mode by pressing specific keys while Chrome OS is booting:

Caution: Modifications you make to the system are not supported by Google, may cause hardware, software or security issues and may void warranty.

NOTE: Putting your device into developer mode inherently makes it a little less secure. Specifically, it makes the “verified boot” that's built-in to your hardware a little bit more lax, allowing your hardware to run custom (non-Google-signed) images. It also gives you access to a “root” shell.

If you’re encountering issues putting your device into Developer Mode, it's possible that your device administrator has blocked Developer Mode access on your device. Please follow the link to read more details about blocked Developer Mode.

You can tell that you're in Developer Mode if you see one of these screens when you turn the device on:

developer mode 1developer mode 2developer mode 3developer mode 4

Switch to Normal Mode

To restore your device to Normal Mode (i.e., disable Developer Mode), reboot your device and perform the following action:

  • Device with keyboard: Press the at the firmware screen.
  • Devices without keyboard (tablet): Use the and keys to select the option. Press the button to confirm.

NOTE: If you‘ve made changes to the rootfs filesystem while in developer mode, you may have to use the recovery process to restore your device to its factory condition. However, as long as you don’t crack open the case, you shouldn‘t be able to do anything that can’t be undone by recovery (software).

Getting to a Command Prompt

If you‘re a Linux hacker, you probably know that Google Chrome OS is built on top of Linux and you’re wondering how you can jailbreak your device so you can get to a command prompt. It turns out: there's no need. The command prompt is built in to your device!

NOTE: Before following these instructions, remember to put your device into Developer Mode.

Get the Command Prompt Through VT-2

One way to get the login prompt is through something called , or “virtual terminal 2”. If you're a Linux user, this is probably familiar. You can get to by pressing:

[ Ctrl ] [ Alt ] [ → ]

where the key is the right-arrow key just above the number on your keyboard.

Once you have the login prompt, you should see a set of instructions telling you about command-line access. By default, you can login as the user with no password. This includes the ability to do password-less . The instructions on the screen will tell you how you can set a password. They also tell you how to disable screen dimming.

In order to get back to the browser press:

[ Ctrl ] [ Alt ] [ ← ]

where the key is the left-arrow key just above the number on your keyboard.

NOTE: The top-rows of the keyboard on a Chrome OS device are actually treated by Linux as the keys through . Thus, the key is actually and the key is actually .

NOTE: Kernel messages show up on .

Getting the Command Prompt Through “crosh”

An alternate way to get to a terminal prompt is to use []:

  1. Go through the standard Chrome OS login screen (you‘ll need to setup a network, etc) and get to the web browser. It’s OK if you login as guest.
  2. Press to get the [] shell.
  3. Use the shell command to get the shell prompt. NOTE: even if you set a password for the chronos user, you won't need it here (though you still need it for sudo access)

NOTE: Entering the shell this way doesn't give you all the instructions that does (like how to set your password). You might want to follow the steps once just to get the instructions.

If you want to get back to the browser without killing the shell, you can use .

NOTE: You can create as many shells as you want with again and another shell will be opened. You can between them.

Making Changes to the Filesystem

The Chromium OS rootfs is mounted read-only. In developer mode you can disable the rootfs verification, enabling it to be modified.

NOTE: If you mount the root filesystem in writeable mode, even if you make no changes, it will no longer be verifiable and you'll have to use a recovery image to restore your system when you switch back to normal mode. Auto updates may also fail until a full payload is downloaded.

To make your rootfs writable, run the following command from a shell on the device:

(dut) $ sudo /usr/share/vboot/bin/ --remove_rootfs_verification

Then reboot. Your rootfs will be mounted read/write.

Specifying Command Line Flags for Chrome

Booting from USB or SD card

Chromium OS can be installed on a USB stick or SD card, for example if you build it yourself. In order to boot these, you have to first enable booting from external storage by opening a shell and running the command . (Even though this only says USB, it will also work for SD cards.)

Afterwards, reboot the device and use the method appropriate for your device to trigger external storage boot when you see the developer mode boot screen.

Running an alternative bootloader (“legacy BIOS”)

You can install an alternative bootloader that may make it easier to boot other operating systems. This does not require you to disable firmware write protection (with its associated risks).

NOTE: Some Chrome OS devices may ship with one or more alternative bootloaders pre-installed. These are merely provided as examples of how to set up the alternative bootloader feature. They are not officially supported, usually not tested and may or may not work at all or do anything useful. The point of the alternative bootloader feature is just to allow users to install their own -- we may occasionally pre-install software if it is readily available, but we are not committing to test and maintain it or to provide the same set across all platforms.

You can also find ready-made alternative bootloaders to install on third-party community sites such as Note that these sites are not affiliated with Google or the Chromium OS project and we are not responsible for any issues or damages arising from them. Use at your own risk.

Alternative bootloaders must be packaged as a coreboot payload and installed in the section of the firmware flash. You can read out the flash and print the contents of this section by opening a shell and running

flashrom -r /tmp/bios.bin cbfstool /tmp/bios.bin print -r RW_LEGACY

If you see a file called in this output, you have a 2019+ platform that supports having more than one alternative bootloader installed at the same time. Otherwise, you can only install a single bootloader that must be called . In that case you may need to remove an already installed bootloader via to make room.

The new bootloader you want to add should be formatted as an ELF file. Make sure that the entry point information in the file is correctly set and that it contains code able to run in a firmware environment (i.e. no operating system support, nothing set up other than what coreboot usually provides to its payloads). Then add the file via

cbfstool /tmp/bios.bin add-payload -r RW_LEGACY -c lzma -n <your bootloader name> -f <path/to/your/bootloader.elf>

On an older platform make sure the name is and you're done. On a newer platform, you can choose any name you want but you need to enter it in the bootloader directory file. Extract this file with

cbfstool /tmp/bios.bin extract -r RW_LEGACY -n altfw/list -f /tmp/altfw.txt

and edit with a normal text editor (e.g. ). The file contains one line per bootloader with the following values separated by semicolons:

  1. Number of the bootloader in the developer mode menu (0 through 9)
    • NOTE: The bootloader number 0 is always the “default” that will boot if is set and the developer boot screen timer runs out.
  2. Name of the bootloader in CBFS (i.e. the parameter to )
  3. Name of the bootloader that shall appear in the developer mode menu
  4. Comment field for more detailed description (not used by firmware)

Add a line for the bootloader you just added, save the file, then replace the file in CBFS with the updated version via

cbfstool /tmp/bios.bin remove -r RW_LEGACY -n altfw/list cbfstool /tmp/bios.bin add -r RW_LEGACY -n altfw/list -f /tmp/altfw.txt -t raw

You may also want to delete the file, if present. This will prevent future Chrome OS system updates from overwriting the alternative bootloader section after you modified it:

cbfstool /tmp/bios.bin remove -r RW_LEGACY -n cros_allow_auto_update

Finally, you must write the modified CBFS section back to the firmware flash and tell the firmware to enable the alternative bootloader feature:

flashrom -w /tmp/bios.bin -i RW_LEGACY crossystem dev_boot_legacy=1

Now you can reboot and use the method appropriate for your device to run your alternative bootloader when you see the developer mode boot screen.

Android development on Chrome OS

How to enable Developer mode on a Chromebook in just a few minutes

Eric Zeman / Android Authority

Chrome OS devices are getting more powerful and capable, allowing for a pretty good, albeit simple, PC experience. If you want to go beyond the basic capabilities of your Chromebook, though, you’ll have to enable Chrome OS Developer Mode. This post will explain exactly how to do it and what to look out for when you’re at it.

Here:What is a Chromebook and what can it do?

Warning: Remember that enabling Chrome OS Developer Mode opens up your computer to abilities that aren’t officially supported. Make sure to do your research, and keep in mind that unsupported and experimental features can cause problems. The responsibility falls only upon you if something happens to your software or hardware. 

What is Chrome OS Developer Mode, anyway?

Eric Zeman / Android Authority

Chrome OS Developer Mode is similar to gaining root access on your Android device. It gives you more control over your Chromebook and is a great option for those who love tweaking their devices.

Developer Mode isn’t for everyone and has several drawbacks, which we’ll get to later on. But if you want to gain root access to the Chrome OS’s file system to do things like sideload Android apps or install an additional OS, among many other things, enabling Developer Mode is the way to go.

How to enable Chromebook Developer Mode

Eric Zeman / Android Authority

First, make sure you back up and save any important files you have stored on your device. Enabling Developer Mode wipes your login info and any locally stored data, which cannot be restored.

How to enable Developer Mode:

  1. Turn on your Chromebook.
  2. Press and hold the Esc key, refresh key, and the power button at the same time.
  3. When the “Chrome OS is missing or damaged. Please insert a recovery USB stick or SD Card.” message shows up, press and hold the Ctrl and D keys simultaneously.
  4. Some Chromebooks may require you to turn OS verification off. Press Enter (if required).
  5. Wait for the device to restart and go through the Chromebook setup process.
  6. You will get an odd screen saying that OS verification is off. Keep in mind this screen will happen every single time you boot up.
  7. Press Ctrl and D to restart successfully.

Also:The best Chromebooks you can buy

How to disable Chrome OS Developer mode

Eric Zeman / Android Authority

As easy as it is to enable Chromebook Developer Mode, it is even simpler to disable it. But remember to backup your data once again, as disabling Developer Mode also erases everything from your Chrome OS device.

How to disable Developer Mode:

  1. Turn on your Chromebook or reboot it if it’s already on.
  2. When the screen that says “OS verification is off” shows up, press the spacebar.
  3. This will technically perform a factory data reset and wipe the laptop clean.
  4. Go through the Chromebook setup process again.

That’s all there is to it!

Also read:How to reset a Chromebook

Drawbacks of enabling Developer mode

David Imel / Android Authority

There are a lot of advantages to enabling Developer Mode on your Chromebook. It gives you access to the developer shell, allows you to install a standard Linux desktop environment, and is something you will need to enable if you are a Chrome OS developer.

Developer Mode is certainly not for the average user, and some technical know-how is needed to take full advantage of this mode. It also has a few disadvantages that you need to be wary of — check them out below.

  • Google doesn’t support Developer mode, so you may be at risk of voiding your device’s warranty.
  • All the security features are disabled when Developer Mode is turned on.
  • You lose your data when enabling or disabling Developer Mode. As you can see from the steps required to disable it, an accidental press of the spacebar at the wrong time is all you need to lose all your data once again. Making continuous backups if you’re working on something important is recommended.
  • Chromebooks boot up extremely fast, which is a feature you will lose when Developer mode is enabled. You’ll have to see that warning screen every single time you switch on the device.

Read next:The best Chromebook deals you can get right now

You’ll likely have plenty of other questions. Don’t worry; we’re here to help. Here are some resources to make life with your new Chromebook easier.

Android DevelopmentHow ToChromebooks, Google Chrome OS


Development chrome os

Chrome OS

Linux-based operating system developed by Google

This article is about the operating system. For the web browser, see Google Chrome.

The Chrome OS logo as of 2020.png

The Chrome OS logo as of July 2020

A screenshot of Chrome OS r87.png

Chrome OS 87 Desktop

Written inC, C++, assembly, JavaScript, HTML5, Python, Rust
OS familyLinux (Unix-like)[1]
Working statePreinstalled on Chromebooks, Chromeboxes, Chromebits, Chromebases, Chromeblets
Source modelClosed-source with open-source components
Initial releaseJune 15, 2011; 10 years ago (2011-06-15)
Latest release94.0.4606.97 (October 14, 2021; 3 days ago (2021-10-14)[2]) [±]
Latest preview

94.0.4606.97 (October 13, 2021; 4 days ago (2021-10-13)[3]) [±]

96.0.4664.4 (October 12, 2021; 5 days ago (2021-10-12)[4]) [±]
Update methodRolling release
Package managerPortage[a]
PlatformsARM32, ARM64, x86, x86-64
Kernel typeMonolithic (Linux kernel)[6]
UserlandAura Shell (Ash), Ozone (display manager); X11 apps can be enabled in recent Chrome OS
user interface
Google Chrome
Official this at Wikidata

Chrome OS (sometimes styled as chromeOS) is a Gentoo Linux-based operating system designed by Google. It is derived from the free softwareChromium OS and uses the Google Chrome web browser as its principal user interface. Unlike Chromium OS, Chrome OS is proprietary software.

Google announced the project, based on Ubuntu,[8] in July 2009, conceiving it as an operating system in which both applications and user data reside in the cloud: hence Chrome OS primarily runs web applications.[9] Source code and a public demo came that November. The first Chrome OS laptop, known as a Chromebook, arrived in May 2011. Initial Chromebook shipments from Samsung and Acer occurred in July 2011.

Chrome OS has an integrated media player and file manager. It supports Progressive Web Apps and Chrome Apps, these resemble native applications, as well as remote access to the desktop. As more Chrome OS machines have entered the market, the operating system is now seldom evaluated apart from the hardware that runs it.[10]

Android applications started to become available for the operating system in 2014, and in 2016, access to Android apps in Google Play's entirety was introduced on supported Chrome OS devices. Support for a Linux terminal and applications, known as Project Crostini,[11] was released to the stable channel in 2018 with Chrome OS 69. This was made possible via a lightweight Linux kernel that runs containers inside a virtual machine.

Chrome OS is only available pre-installed on hardware from Google manufacturing partners, but there are unofficial methods that allow it to be installed in other equipment.[12] Its open-source upstream, Chromium OS, can be compiled from downloaded source code. Early on, Google provided design goals for Chrome OS, but has not otherwise released a technical description.


Google announced Chrome OS on July 7, 2009,[1] describing it as an operating system in which both applications and user data reside in the cloud. To ascertain marketing requirements, the company relied on informal metrics, including monitoring the usage patterns of some 200 Chrome OS machines used by Google employees. Developers also noted their own usage patterns. Matthew Papakipos, the former[13] engineering director for the Chrome OS project, put three machines in his house and found himself logging in for brief sessions: to make a single search query or send a short email.[14]

The initial builds of Chrome OS were based on Ubuntu, and its developer, Canonical, was an engineer partner with Google on the project. In 2010, Chrome OS moved to Gentoo Linux as its base to simplify its build process and support a variety number of platforms. Sometime in 2013, Google switched Chrome OS to its own flavour of Linux.[8]

Chrome OS was initially intended for secondary devices like netbooks, not as a user's primary PC.[15][16] While Chrome OS supports hard disk drives, Google has requested that its hardware partners use solid-state drives "for performance and reliability reasons"[17] as well as the lower capacity requirements inherent in an operating system that accesses applications and most user data on remote servers. In November 2009 Matthew Papakipos, engineering director for the Chrome OS, claimed that the Chrome OS consumes one-sixtieth as much drive space as Windows 7.[18] The recovery images Google provides for Chrome OS range between 1 and 3 GB.[19]

On November 19, 2009, Google released Chrome OS's source code as the Chromium OS project.[20] At a November 19, 2009, news conference, Sundar Pichai, at the time Google's vice president overseeing Chrome, demonstrated an early version of the operating system. He previewed a desktop which looked very similar to the Chrome browser, and in addition to the regular browser tabs, also had application tabs, which take less space and can be pinned for easier access. At the conference, the operating system booted up in seven seconds, a time Google said it would work to reduce.[17][15][21][22] Additionally, Chris Kenyon, vice president of OEM services at Canonical Ltd, announced that Canonical was under contract to contribute engineering resources to the project with the intent to build on existing open-source components and tools where feasible.[23]

Early Chromebooks[edit]

In 2010, Google released the unbranded Cr-48 Chromebook in a pilot program.[24][25] The launch date for retail hardware featuring Chrome OS was delayed from late 2010[26] until the next year. On May 11, 2011, Google announced two Chromebooks from Acer and Samsung at Google I/O.[27][28] The Samsung model was released on June 15, 2011, but the Acer was delayed until mid-July.[29][30] In August 2011, Netflix announced official support for Chrome OS through its streaming service, allowing Chromebooks to watch streaming movies and TV shows via Netflix. At the time, other devices had to use Microsoft Silverlight to play videos from Netflix.[31] Later in that same month, Citrix released a client application for Chrome OS, allowing Chromebooks to access Windows applications and desktops remotely.[32] Dublin City University became the first educational institution in Europe to provide Chromebooks for its students when it announced an agreement with Google in September 2011.[33]


By 2012, demand for Chromebooks had begun to grow, and Google announced a new range of devices, designed and manufactured by Samsung. In so doing, they also released the first Chromebox, the Samsung Series 3, which was Chrome OS's entrance into the world of desktop computers.[34] Although they were faster than the previous range of devices, they were still underpowered compared to other desktops and laptops of the time, fitting in more closely with the Netbook market. Only months later, in October, Samsung and Google released a new Chromebook at a significantly lower price point ($250, compared to the previous Series 5 Chromebooks' $450).[35] It was the first Chromebook to use an ARM processor, one from Samsung's Exynos line. In order to reduce the price, Google and Samsung also reduced the memory and screen resolution of the device. An advantage of using the ARM processor, however, was that the Chromebook didn't require a fan. Acer followed quickly after with the C7 Chromebook, priced even lower ($199), but containing an Intel Celeron processor.[36] One notable way Acer reduced the cost of the C7 was to use a laptop hard disk rather than a solid-state drive.

In April 2012, Google made the first update to Chrome OS's user interface since the operating system had launched, introducing a hardware-accelerated window manager called "Aura" along with a conventional taskbar. The additions marked a departure from the operating system's original concept of a single browser with tabs and gave Chrome OS the look and feel of a more conventional desktop operating system. "In a way, this almost feels as if Google is admitting defeat here", wrote Frederic Lardinois on TechCrunch. He argued that Google had traded its original version of simplicity for greater functionality. "That's not necessarily a bad thing, though, and may just help Chrome OS gain more mainstream acceptance as new users will surely find it to be a more familiar experience."[37]Lenovo and HP followed Samsung and Acer in manufacturing Chromebooks in early 2013 with their own models.[38] Lenovo specifically targeted their Chromebook at students, headlining their press release with "Lenovo Introduces Rugged ThinkPad Chromebook for Schools".[39][40]

When Google released Google Drive, they also included Drive integration in Chrome OS version 20, released in July 2012.[41] While Chrome OS had supported Flash since 2010,[42] by the end of 2012 it had been fully sandboxed, preventing issues with Flash from affecting other parts of Chrome OS.[43] This affected all versions of Chrome including Chrome OS.

Chromebook Pixel[edit]

Chromebook Pixel (Wi-Fi) open

Main article: Chromebook Pixel

Up to this point, Google had never made their own Chrome OS device. Instead, Chrome OS devices were much more similar to their Nexus line of Android phones, with each Chrome OS device being designed, manufactured, and marketed by third-party manufacturers, but with Google controlling the software. However, in February 2013 this changed when Google released the Chromebook Pixel.[44] The Chromebook Pixel was a departure from previous devices. Not only was it entirely Google-branded, but it contained an Intel i5 processor, a high-resolution (2,560x1,700) touchscreen display, and came at a price more competitive with business laptops.[45]

Controversial popularity[edit]

By the end of 2013, analysts were undecided on the future of Chrome OS. Although there had been articles predicting the demise of Chrome OS since 2009,[46][47][48][49][50] Chrome OS device sales continued to increase substantially year-over-year. In mid-2014, Time magazine published an article titled "Depending on Who's Counting, Chromebooks are Either an Enormous Hit or Totally Irrelevant", which detailed the differences in opinion.[51] This controversy was further spurred by the fact that Intel seemed to decide Chrome OS was a beneficial market for it, holding their own Chrome OS events where they announced new Intel-based Chromebooks, Chromeboxes, and an all-in-one from LG called the Chromebase.[52]

Seizing the opportunity created by the end of life for Windows XP, Google pushed hard to sell Chromebooks to businesses, offering significant discounts in early 2014.[53]

Chrome OS devices outsold Apple Macs worldwide for the year 2020.[54][55][56]

Pwnium competition[edit]

In March 2014, Google hosted a hacking contest aimed at computer security experts called "Pwnium". Similar to the Pwn2Own contest, they invited hackers from around the world to find exploits in Chrome OS, with prizes available for attacks. Two exploits were demonstrated there, and a third was demonstrated at that year's Pwn2Own competition. Google patched the issues within a week.[57]

Material Design and app runtime for Chrome[edit]

Although the Google Native Client has been available on Chrome OS since 2010,[58] there originally were few Native Client apps available, and most Chrome OS apps were still web apps. However, in June 2014, Google announced at Google I/O that Chrome OS would both synchronise with Android phones to share notifications and begin to run Android apps, installed directly from Google Play.[59] This, along with the broadening selection of Chromebooks,[60] provided an interesting future for Chrome OS.

At the same time, Google was also moving towards the then-new Material Designdesign language for its products, which it would bring to its web products as well as Android Lollipop.[61] One of the first Material Design items to come to Chrome OS was a new default wallpaper,[62] though Google did release some screenshots of a Material Design experiment for Chrome OS that never made it into the stable version.[63]

Functionality for small and medium businesses and Enterprise[edit]

Chrome Enterprise[edit]

Chrome Enterprise, launched in 2017, includes Chrome OS, Chrome Browser, Chrome devices and their management capabilities intended for business use. Businesses can access the standard Chrome OS features and unlock advanced features for business with the Chrome Enterprise Upgrade.[64][65] Standard features include the ability to sync bookmarks and browser extensions across devices, cloud or native printing, multi-layered security, remote desktop, and automatic updates.[66] Advanced features include Active Directory integration, unified endpoint management, advanced security protection, access to device policies and Google Admin console, guest access, kiosk mode, and whitelisting or blacklisting third-party apps managed on Google Play.[67][68]

The education sector was an early adopter of Chromebooks, Chrome OS, and cloud-based computing. Chromebooks are widely used in classrooms and the advantages of cloud-based systems have been gaining an increased share of the market in other sectors as well, including financial services, healthcare and retail.[69] "The popularity of cloud computing and cloud-based services highlights the degree to which companies and business processes have become both internet-enabled and dependent."[70] IT managers cite a number of advantages of the cloud that have motivated the move. Among them are advanced security, because data is not physically on a single machine that can be lost or stolen.[71] Deploying and managing cloud-native devices is easier because no hardware and software upgrades or virus definition updates are needed and patching of OS and software updates is simpler. Simplified and centralized management decreases operational costs.

Employees can securely access files and work on any machine, increasing the shareability of Chrome devices. Google's Grab and Go program with Chrome Enterprise allows businesses deploying Chromebooks to provide employees access to a bank of fully charged computers that can be checked out and returned after a period of time.[72]

From Chromebooks to Chromebox and Chromebase[edit]

In an early attempt to expand its enterprise offerings, Google released Chromebox for Meetings in February 2014. Chromebox for Meetings is a kit for conference rooms containing a Chromebox, a camera, a unit containing both a noise-cancelling microphone and speakers, and a remote control. It supports Google Hangouts meetings, Vidyo video conferences, and conference calls from UberConference.[73][74]

Several partners announced Chromebox for Meetings models with Google, and in 2016 Google announced an all-in-one Chromebase for Meetings for smaller meeting rooms.[75] Google targeted the consumer hardware market with the release of the Chromebook in 2011 and Chromebook Pixel in 2013, and sought access to the enterprise market with the 2017 release of the Pixelbook. The second-generation Pixelbook was released in 2019.[76] In 2021 there are several vendors selling all-in-one Chromebase devices.[77]

Enterprise response to Chrome devices[edit]

Google has partnered on Chrome devices with several leading OEMs, including Acer, ASUS, Dell, HP, Lenovo, and Samsung.

In August 2019, Dell announced that two of its popular business-focused laptops would run Chrome OS and come with Chrome Enterprise Upgrade. The Latitude 5300 2-in-1 Chromebook Enterprise and Latitude 5400 Chromebook Enterprise were the result of a two-year partnership between Dell and Google.[78] The machines come with a bundle of Dell's cloud-based support services that would enable enterprise IT managers to deploy them in environments that also rely on Windows.[79] The new laptop line "delivers the search giant's Chrome OS operating system in a form tailored for security-conscious organizations."[80] Other OEMs that have launched devices with Chrome Enterprise Upgrade include Acer and HP.[81]

With a broader range of hardware available, Chrome OS became an option for enterprises wishing to avoid a migration to Windows 10 before Windows 7 support was discontinued by Microsoft.[82]


Main articles: Chromebook, Chromebox, and Chromebit

Laptops running Chrome OS are known collectively as "Chromebooks". The first was the CR-48, a reference hardware design that Google gave to testers and reviewers beginning in December 2010. Retail machines followed in May 2011. A year later, in May 2012, a desktop design marketed as a "Chromebox" was released by Samsung. In March 2015 a partnership with AOPEN was announced and the first commercial Chromebox was developed.[83]

In early 2014, LG Electronics introduced the first device belonging to the new all-in-one form factor called "Chromebase". Chromebase devices are essentially Chromebox hardware inside a monitor with a built-in camera, microphone and speakers.

The Chromebit is an HDMI dongle running Chrome OS. When placed in an HDMI slot on a television set or computer monitor, the device turns that display into a personal computer. The first device, announced in March 2015 was an Asus unit that shipped that November and which reached end of life in November 2020.[84]

Chromebook tablets were introduced in March 2018 by Acer with their Chromebook Tab 10. Designed to rival the Apple iPad, it had an identical screen size and resolution and other similar specifications, a notable addition was a Wacom-branded stylus that doesn’t require a battery or charging.[85]

Chrome OS supports multi-monitor setups, on devices with a video-out port, USB 3.0 or USB-C, the latter being preferable.[86]


The software and updates are limited in their support lifetime.[87][88] Each device model manufactured to run Chrome OS has a different end-of-life date, with all new devices released in 2020 and beyond guaranteed to receive a minimum of eight years from their date of initial release.[89]

As of Version 78, the device's end-of-life date for software updates is listed in "About Chrome OS"-"Additional Details".[90]


Initially, Chrome OS was almost a pure web thin client operating system that relied primarily on servers to host web applications and related data storage.[91][92] Google gradually began encouraging developers to create "packaged applications", and later, Chrome Apps. The latter employ HTML5, CSS, Adobe Shockwave, and JavaScript to provide a user experience closer to a native application.[93][94]

In September 2014, Google launched App Runtime for Chrome (beta), which allowed certain ported[95] Android applications to run on Chrome OS. Runtime was launched with four Android applications: Duolingo, Evernote, Sight Words, and Vine.[96] In 2016, Google made Google Play available for Chrome OS, making most Android apps available for supported Chrome OS devices.[97]

In 2018, Google announced plans for Chrome OS support for desktop Linux apps.[98] This capability was released to the stable channel (as an option for most machines) with Chrome 69 in October 2018, but was still marked as beta.[99] This feature was officially released with Chrome 91.[100]

By default X11 is not used,[101] while X11 apps can be run[102]Project Crostini makes X11 work (through Wayland).[103]

Chrome Apps[edit]

Main article: Google Chrome App

From 2013 until January 2020, Google encouraged developers to build not just conventional Web applications for Chrome OS, but Chrome Apps (formerly known as Packaged Apps).[104] In January 2020, Google's Chrome team announced its intent to phase out support for Chrome Apps in favor of "progressive web applications" (PWA) and Chrome extensions instead.[105] In March 2020, Google stopped accepting new public Chrome Apps for the web store.[106] According to Google, general support for Chrome Apps on Chrome OS will remain enabled, without requiring any policy setting, through June 2022.[106]

From a user's perspective, Chrome Apps resemble conventional native applications: they can be launched outside of the Chrome browser, are offline by default, can manage multiple windows, and interact with other applications. Technologies employed include HTML5, JavaScript, and CSS.[107][108][109]

Integrated media player, file manager[edit]

Google integrates a media player into both Chrome OS and the Chrome browser, enabling users to play back MP3s, view JPEGs, and handle other multimedia files while offline.[110] It also supports DRM videos.[111]

Chrome OS also includes an integrated file manager, resembling those found on other operating systems, with the ability to display directories and the files they contain from both Google Drive and local storage, as well as to preview and manage file contents using a variety of Web applications, including Google Docs and Box.[112] Since January 2015, Chrome OS can also integrate additional storage sources into the file manager, relying on installed extensions that use the File System Provider API.[113]

Remote application access and virtual desktop access[edit]

In June 2010, Google software engineer Gary Kačmarčík wrote that Chrome OS would access remote applications through a technology unofficially called "Chromoting", which would resemble Microsoft's Remote Desktop Connection.[110] The name has since been changed to "Chrome Remote Desktop", and is like "running an application via Remote Desktop Services or by first connecting to a host machine by using RDP or VNC".[114] Initial roll-outs of Chrome OS laptops (Chromebooks) indicate an interest in enabling users to access virtual desktops.[115][116]

Android applications[edit]

At Google I/O 2014, a proof of concept showing Android applications, including Flipboard, running on Chrome OS was presented. In September 2014, Google introduced a beta version of the App Runtime for Chrome (ARC), which allows selected Android applications to be used on Chrome OS, using a Native Client-based environment that provides the platforms necessary to run Android software. Android applications do not require any modifications to run on Chrome OS, but may be modified to better support a mouse and keyboard environment. At its introduction, Chrome OS support was only available for selected Android applications.[117]

In 2016, Google introduced the ability to run Android apps on supported Chrome OS devices, with access to Google Play in its entirety. The previous Native Client-based solution was dropped in favor of a container containing Android's frameworks and dependencies (initially based on Android Marshmallow), which allows Android apps to have direct access to the Chrome OS platform, and allow the OS to interact with Android contracts such as sharing. Engineering director Zelidrag Hornung explained that ARC had been scrapped due to its limitations, including its incompatibility with the Android Native Development Toolkit (NDK), and that it was unable to pass Google's own compatibility test suite.[118][119]

Linux apps[edit]

All Chromebooks since 2018 and many earlier models can run full-fledged Linux apps; as with Android apps, they can be installed and launched alongside other apps.[120] Google maintains a list of devices that were launched before 2019, which support Linux apps.[121][122]

Since 2013, it has been possible to run Linux applications in Chrome OS through the use of Crouton, a third-party set of scripts that allows access to a Linux distribution such as Ubuntu.[123] However, in 2018 Google announced that desktop Linux apps were officially coming to Chrome OS.[124] The main benefit claimed by Google of their official Linux application support is that it can run without enabling developer mode, keeping many of the security features of Chrome OS. It was noticed in the Chromium OS source code in early 2018.[125][126] Early parts of Crostini were made available for the Google Pixelbook via the dev channel in February 2018 as part of Chrome OS version 66,[127][128] and it was enabled by default via the beta channel for testing on a variety of Chromebooks in August 2018 with version 69.[129]


Google's project for supporting Linux applications in Chrome OS is called Crostini, named for the Italian bread-based starter, and as a pun on Crouton. Crostini runs a virtual machine through a virtual machine monitor called crosvm, which uses Linux's built-in KVM virtualization tool. Although crosvm supports multiple virtual machines, the one used for running Linux apps, Termina, contains a basic Chrome OS kernel and userland utilities, in which it runs containers based on Linux containers (specifically LXD).[11]

Windows apps[edit]

In late 2020, Parallels launched Parallels Desktop for Chrome OS, which allows Windows 10 virtual machines to be run on Chromebook Enterprise devices.[130]


Chrome OS is built on top of the Linux kernel. Originally based on Ubuntu, its base was changed to Gentoo Linux in February 2010.[131] For Project Crostini, as of Chrome OS 80, Debian 10 (Buster) is used.[132] In preliminary design documents for the Chromium OS open-source project, Google described a three-tier architecture: firmware, browser and window manager, and system-level software and userland services.[133]

  • The firmware contributes to fast boot time by not probing for hardware, such as floppy disk drives, that are no longer common on computers, especially netbooks. The firmware also contributes to security by verifying each step in the boot process and incorporating system recovery.[133]
  • System-level software includes the Linux kernel that has been patched to improve boot performance. Userland software has been trimmed to essentials, with management by Upstart, which can launch services in parallel, re-spawn crashed jobs, and defer services in the interest of faster booting.[133]
  • The window manager handles user interaction with multiple client windows (much like other X window managers).[133]


In March 2010, Google software security engineer Will Drewry discussed Chrome OS security. Drewry described Chrome OS as a "hardened" operating system featuring auto-updating and sandbox features that would reduce malware exposure. He said that Chrome OS netbooks would be shipped with Trusted Platform Module (TPM), and include both a "trusted bootpath" and a physical switch under the battery compartment that activates a "developer mode". That mode drops some specialized security functions but increases developer flexibility. Drewry also emphasized that the open-source nature of the operating system would contribute greatly to its security by allowing constant developer feedback.[134]

At a December 2010 press conference, Google declared that Chrome OS would be the most secure consumer operating system due in part to a verified boot ability, in which the initial boot code, stored in read-only memory, checks for system compromises.[135] In the following nine years, Chrome OS has been affected by 55 documented security flaws of any severity,[136] compared with over 1,100 affecting Microsoft Windows 10 in the five years to the end of 2019[137] and over 2,200 affecting Apple OS X in 20 years.[138]

Shell access[edit]

Chrome OS includes the Chrome Shell, or "crosh",[139] which documents minimal functionality such as ping at crosh start-up.

In developer mode, a full-featured bash[140] shell (which is supposed to be used for development purposes[141]) can be opened via VT-2, and is also accessible using the crosh command .[142] To access full privileges in shell (e.g. sudo) a root password is requested. For some time the default was "chronos" in Chrome OS and "facepunch" in Chrome OS Vanilla[143] and later the default was empty, and instructions on updating it were displayed at each login.

Open source[edit]

Chrome OS is partially developed under the open-sourceChromium OS project.[144] As with other open-source projects, developers can modify the code from Chromium OS and build their own versions, whereas Chrome OS code is only supported by Google and its partners and only runs on hardware designed for the purpose. Unlike Chromium OS, Chrome OS is automatically updated to the latest version.[17]

Chrome OS on Windows[edit]

On Windows 8, exceptions allow the default desktop web browser to offer a variant that can run inside its full-screen "Metro" shell and access features such as the Share charm, without necessarily needing to be written with Windows Runtime. Chrome's "Windows 8 mode" was previously a tablet-optimized version of the standard Chrome interface. In October 2013, the mode was changed on Developer channel to offer a variant of the Chrome OS desktop.[145][146][147][148][149]


Early in the project, Google provided publicly many details of Chrome OS's design goals and direction,[150] although the company has not followed up with a technical description of the completed operating system.

User interface[edit]

Design goals for Chrome OS's user interface included using minimal screen space by combining applications and standard Web pages into a single tab strip, rather than separating the two. Designers considered a reduced window management scheme that would operate only in full-screen mode. Secondary tasks would be handled with "panels": floating windows that dock to the bottom of the screen for tasks like chat and music players. Split screens were also under consideration for viewing two pieces of content side by side. Chrome OS would follow the Chrome browser's practice of leveraging HTML5's offline modes, background processing, and notifications. Designers proposed using search and pinned tabs as a way to quickly locate and access applications.[151]

Version 19 window manager and graphics engine[edit]

On April 10, 2012, a new build of Chrome OS offered a choice between the original full-screen window interface and overlapping, re-sizable windows, such as found on Microsoft Windows and Apple's macOS.[152] The feature was implemented through the Ash window manager, which runs atop the Aura hardware-accelerated graphics engine. The April 2012 upgrade also included the ability to display smaller, overlapping browser windows, each with its own translucent tabs, browser tabs that can be "torn" and dragged to new positions or merged with another tab strip, and a mouse-enabled shortcut list across the bottom of the screen. One icon on the task bar shows a list of installed applications and bookmarks. Writing in CNET, Stephen Shankland argued that with overlapping windows, "Google is anchoring itself into the past" as both iOS and Microsoft's Metro interface are largely or entirely full-screen. Even so, "Chrome OS already is different enough that it's best to preserve any familiarity that can be preserved".[152][153][154]


Google Cloud Print is a Google service that helps any application on any device to print on supported printers. While the cloud provides virtually any connected device with information access, the task of "developing and maintaining print subsystems for every combination of hardware and operating system—from desktops to netbooks to mobile devices—simply isn't feasible."[155][156] The cloud service requires installation of a piece of software called proxy, as part of the Chrome OS. The proxy registers the printer with the service, manages the print jobs, provides the printer driver functionality, and gives status alerts for each job.[157]

In 2016, Google included "Native CUPS Support" in Chrome OS as an experimental feature that may eventually become an official feature. With CUPS support turned on, it becomes possible to use most USB printers even if they do not support Google Cloud Print.[158][159]

Google announced that Google Cloud Print would no longer be supported after December 31, 2020 and that the online service would not be available as of January 1, 2021.[160]

Link handling[edit]

Chrome OS was designed with the intention of storing user documents and files on remote servers. Both Chrome OS and the Chrome browser may introduce difficulties to end users when handling specific file types offline; for example, when opening an image or document residing on a local storage device, it may be unclear whether and which specific Web application should be automatically opened for viewing, or the handling should be performed by a traditional application acting as a preview utility. Matthew Papakipos, Chrome OS engineering director, noted in 2010 that Windows developers have faced the same fundamental problem: "Quicktime is fighting with Windows Media Player, which is fighting with Chrome."[14]

Release channels and updates[edit]

Chrome OS uses the same release system as Google Chrome: there are three distinct channels: Stable, Beta, and Developer preview (called the "Dev" channel). The stable channel is updated with features and fixes that have been thoroughly tested in the Beta channel, and the Beta channel is updated approximately once a month with stable and complete features from the Developer channel. New ideas get tested in the Developer channel, which can be very unstable at times.[161][162] A fourth canary channel was confirmed to exist by Google Developer Francois Beaufort and hacker Kenny Strawn, by entering the Chrome OS shell in developer mode, typing the command shell to access the bash shell, and finally entering the command update_engine_client -channel canary-channel -update. It is possible to return to the verified boot mode after entering the canary channel, but the channel updater disappears and the only way to return to another channel is using the "powerwash" factory reset.[163]


At its debut, Chrome OS was viewed as a competitor to Microsoft, both directly to Microsoft Windows and indirectly the company's word processing and spreadsheet applications—the latter through Chrome OS's reliance on cloud computing.[164][165] But Chrome OS engineering director Matthew Papakipos argued that the two operating systems would not fully overlap in functionality because Chrome OS is intended for netbooks, which lack the computational power to run a resource-intensive program like Adobe Photoshop.[14]

Some observers claimed that other operating systems already filled the niche that Chrome OS was aiming for, with the added advantage of supporting native applications in addition to a browser. Tony Bradley of PC World wrote in November 2009:

We can already do most, if not all, of what Chrome OS promises to deliver. Using a Windows 7 or Linux-based netbook, users can simply not install anything but a web browser and connect to the vast array of Google products and other web-based services and applications. Netbooks have been successful at capturing the low-end PC market, and they provide a web-centric computing experience today. I am not sure why we should get excited that a year from now we'll be able to do the same thing, but locked into doing it from the fourth-place web browser.[166]

In 2016, Chromebooks were the most popular computer in the US K–12 education market.[167]

By 2017, the Chrome browser had risen to become the number one browser used worldwide.[168]

In 2020, Chromebooks became the second most-popular end-user oriented OS (growing from 6.4% in 2019 to 10.8% in 2020). The majority of growth came at Windows expense (which fell from 85.4% in 2019 to 80.5% in 2021).[169]

Relationship to Android[edit]

Google's offering of two open-source operating systems, Android[170] and Chrome OS, has drawn some criticism despite the similarity between this situation and that of Apple Inc.'s two operating systems, macOS and iOS. Steve Ballmer, Microsoft CEO at the time, accused Google of not being able to make up its mind.[171]Steven Levy wrote that "the dissonance between the two systems was apparent" at Google I/O 2011. The event featured a daily press conference in which each team leader, Android's Andy Rubin and Chrome's Sundar Pichai, "unconvincingly tried to explain why the systems weren't competitive."[172] Google co-founder Sergey Brin addressed the question by saying that owning two promising operating systems was "a problem that most companies would love to face".[172] Brin suggested that the two operating systems "will likely converge over time."[173] The speculation over convergence increased in March 2013 when Chrome OS chief Pichai replaced Rubin as the senior vice president in charge of Android, thereby putting Pichai in charge of both.[174]

The relationship between Android and Chrome OS became more substantial at Google I/O 2014, where developers demonstrated native Android software running on Chrome OS through a Native Client-based runtime.[117][175] In September 2014, Google introduced a beta version of the App Runtime for Chrome (ARC), which allows selected Android applications to be used on Chrome OS, using a Native Client-based environment that provides the platforms necessary to run Android software. Android applications do not require any modifications to run on Chrome OS, but may be modified to better support a mouse and keyboard environment. At its introduction, Chrome OS support was only available for selected Android applications.[117] In October 2015, The Wall Street Journal reported that Chrome OS would be folded into Android so that a single OS would result by 2017. The resulting OS would be Android, but it would be expanded to run on laptops.[176][177] Google responded that while the company has "been working on ways to bring together the best of both operating systems, there's no plan to phase out Chrome OS."[178]

In 2016, Google introduced the ability to run Android apps on supported Chrome OS devices, with access to Google Play in its entirety. The previous Native Client-based solution was dropped in favor of a container containing Android's frameworks and dependencies (initially based on Android Marshmallow), which allows Android apps to have direct access to the Chrome OS platform, and allow the OS to interact with Android contracts such as sharing. Engineering director Zelidrag Hornung explained that ARC had been scrapped due to its limitations, including its incompatibility with the Android Native Development Toolkit (NDK), and that it was unable to pass Google's own compatibility test suite.[118][119]

See also[edit]


  1. ^While it is possible to run Portage in Chrome OS, this requires enabling development mode which removes integrity checking for the filesystem.[5]


  1. ^ abPichai, Sundar (July 7, 2009). "Introducing the Google Chrome OS". Official Google Blog. Google, Inc. Retrieved July 11, 2012.
  2. ^"Stable Channel Update for Chrome OS". October 14, 2021. Retrieved October 14, 2021.
  3. ^Matt Nelson (October 13, 2021). "Beta Channel Update for Chrome OS". Retrieved October 14, 2021.
  4. ^Daniel Gagnon (October 12, 2021). "Dev Channel Update for Chrome OS". Retrieved October 13, 2021.
  5. ^"Dev-Install: Installing Developer and Test packages onto a Chrome OS device - The Chromium Projects".
  6. ^"Kernel Design: Background, Upgrades". Retrieved September 7, 2011.
  7. ^Google. "Google Chrome OS Terms of Service". Retrieved September 5, 2012.
  8. ^ abJ. Vaughan-Nichols, Steven (March 6, 2013). "The secret origins of Google's Chrome OS". Archived from the original on February 3, 2021.
  9. ^"Kernel Design". The Chromium Projects.
  10. ^Springer, Jeff (July 12, 2021). "What apps run on Chrome OS? These are the Best Chrome OS apps!". XDA. Retrieved August 31, 2021.
  11. ^ ab"Chromium OS Docs - Running Custom Containers Under Chrome OS".
  12. ^"Chrome OS unofficial forks". Retrieved December 20, 2018.
  13. ^Brodkin, Jon (June 28, 2010). "Google Chrome OS creator takes job at Facebook, announces switch on Twitter". Business Week. Archived from the original on December 30, 2010. Retrieved June 29, 2010.
  14. ^ abcStokes, Jon (January 19, 2010). "Google talks Chrome OS, HTML5, and the future of software". Ars Technica. Retrieved January 23, 2010.
  15. ^ ab"Linux commands". The New York Times.
  16. ^Womack, Brian (July 8, 2009). "Google to Challenge Microsoft With Operating System". Bloomberg. Retrieved July 8, 2009.
  17. ^ abc"Developer FAQ". Retrieved December 12, 2009.
  18. ^Mearian, Lucas (November 19, 2009). "Google Chrome OS will not support hard-disk drives". Computerworld. Retrieved November 21, 2009.
  19. ^"Recover your Chromebook - Chromebook Help".
  20. ^Sengupta, Caesar (November 19, 2009). "Releasing the Chromium OS open source project". Official Google Blog. Google, Inc. Retrieved November 19, 2009.
  21. ^Yegulalp, Serdar (December 5, 2009). "Google Chrome OS Previewed". InformationWeek. Archived from the original on December 8, 2009. Retrieved December 6, 2009.
  22. ^Rapoza, Jim (December 3, 2009). "Review: Google Chrome OS Developer Edition Provides Intriguing Look at Web-Only Computing". Retrieved December 4, 2009.
  23. ^Kenyon, Chris (November 2009). "Google Chrome OS and Canonical". Canonical Blog. Retrieved December 14, 2010.
  24. ^Chan, Casey (December 7, 2010). "Here's the Cr-48, The First Chrome OS Laptop You Can Never Buy". Gizmodo. Archived from the original on June 25, 2016. Retrieved January 9, 2019.
  25. ^"Google Chromebooks - Laptops, Detachables and Tablets". Google Chromebooks.
  26. ^"Google sets "late fall" release for Chrome". Reuters. June 2, 2010.
  27. ^Lawler, Richard (May 11, 2011). "Google unveils Acer Chromebook: $349, 11.6-inches with 6.5-hour battery". Engadget. Retrieved January 9, 2019.
  28. ^Hollister, Sean (May 11, 2011). "Official: Samsung reveals Chrome OS laptop -- the Series 5". Engadget. Retrieved January 9, 2019.
  29. ^Tsukayama, Hayley (June 15, 2011). "Chromebook go on sale". The Washington Post. Retrieved January 9, 2019.
  30. ^Reisinger, Don (June 28, 2011). "Acer AC700 Chromebook available, shipping soon". CNet.
  31. ^Lawler, Richard (August 9, 2011). "Netflix Watch Instantly streaming now works on ChromeOS, when it's working". Engadget.
  32. ^"Citrix app opens Windows for Chromebook owners". Engadget. Retrieved March 9, 2019.
  33. ^Kennedy, John (September 13, 2011). "Dublin City University's five-year plan – Chromebook deal with Google".
  34. ^Kelion, Leo (May 29, 2012). "Google Chrome OS computers updated with faster processors". BBC News.
  35. ^Olivarez-Giles, Nathan (October 18, 2012). "Google Debuts $250 Chromebook". Wired.
  36. ^Joire, Myriam (November 26, 2012). "Acer C7 Chromebook review: Chrome OS on the cheap, but at what cost?".
  37. ^Lardinois, Frederic (April 9, 2012). "Google's Chrome OS Will Soon Look More Like Windows Than A Browser". Techcrunch. Retrieved June 2, 2013.
  38. ^Hollister, Sean (February 4, 2013). "HP's first Chromebook arrives, offers a large screen and a small battery for $329.99".
  39. ^"Lenovo Introduces Rugged ThinkPad Chromebook for Schools". January 17, 2013. Archived from the original on February 5, 2013.
  40. ^Zhekov, Ivan (January 18, 2013). "Lenovo unveils the sturdy ThinkPad X131e Chromebook for students".
  41. ^"Stable Channel Updates for Chromebooks". July 11, 2012.
  42. ^Ganapati, Priya (March 31, 2010). "Google fires at Apple, Integrates Flash into Chrome Browser". Wired.
  43. ^Protalinski, Emil (November 13, 2012). "Google declares Flash is now 'fully sandboxed' in Chrome for Windows, Mac, Linux and Chrome OS". TheNextWeb.
  44. ^"Google unveils its first touchscreen Chromebook Pixel". BBC News. February 21, 2013.
  45. ^"The Chromebook Pixel, for what's next". February 21, 2013.
  46. ^Card, David (December 13, 2010). "Google's Chrome OS: Dead Before Arrival?".
  47. ^Raymond, Scott (August 30, 2011). "Chromebooks are dead, they just don't know it yet".
  48. ^Chacos, Brad (February 4, 2013). "What's with all the Chromebooks?".
  49. ^Yarow, Jay (December 14, 2010). "Google Will Kill Chrome OS Next Year, Predicts Gmail Creator Paul Buchheit".
  50. ^Maguire, Adam (November 26, 2009). "Opinion: Will Google's Chrome OS be dead on arrival?".
  51. ^McCracken, Harry (May 7, 2014). "Depending on Who's Counting, Chromebooks are Either an Enormous Hit or Totally Irrelevant". Time.
  52. ^Anthony, Sebastian (May 7, 2014). "Intel decides that Chromebooks, for some reason, are key to beating ARM in the mobile market".
  53. ^Page, Carly (April 9, 2014). "Google jumps on Windows XP's demise with Chromebook for business offer". The Inquirer. Archived from the original on August 15, 2014.CS1 maint: unfit URL (link)
  54. ^Nagel, David (August 3, 2021). "Chromebooks Continue Massive Surge in Adoption". The Journal. Retrieved August 13, 2021.
  55. ^Protalinski, Emil (February 16, 2021). "Chromebooks outsold Macs worldwide in 2020, cutting into Windows market share". Geekwire. Retrieved August 13, 2021.
  56. ^Moore, Ben (August 3, 2021). "Rise of the Chromebooks continues". CRN. Retrieved August 13, 2021.
  57. ^Vaughan-Nichols, Steven J. (March 18, 2014). "Chrome OS security holes found, patched".
  58. ^Metz, Cade (May 13, 2010). "Google heats up native code for Chrome OS". The Register.
  59. ^Henry, Alan (June 25, 2014). "Chrome OS will Run Android Apps Natively, Sync with Android Devices". LifeHacker.
  60. ^Ackerman, Dan (March 3, 2014). "Chromebooks compared: New and upcoming Chrome OS laptops". Cnet.
  61. ^Brian, Matt (June 25, 2014). "Google's new 'Material Design' UI coming to Android, Chrome OS and the web". Engadget.
  62. ^Dawson, Tom (October 28, 2014). "Chrome OS to Get New Default Wallpaper Full of Material Design".
  63. ^"Google shares sneak peek of Material Design applied to Chrome OS". July 18, 2014.
  64. ^"Google introduces Chrome Enterprise subscription for $50 per Chromebook per year". August 22, 2017.
  65. ^Edwards, Richard (November 23, 2018). "Google Chrome: It's more than a browser". Computer Weekly. Retrieved February 16, 2020.
  66. ^"What is Google Chrome Enterprise? - Definition from".
  67. ^"Google debuts centralized controls for Chrome browser deployments". April 11, 2019.
  68. ^Heller, Michael (August 24, 2017). "Google Chrome Enterprise adds management options". TechTarget. Retrieved February 16, 2020.
  69. ^"Do Google Chromebooks have a place in the enterprise?". SearchVirtualDesktop.
  70. ^"Dell's Latitude Chromebook Aimed at New-Gen Enterprise". eWEEK. August 28, 2019.
  71. ^Pratt, Mary K. (May 31, 2019). "Move to cloud computing lifts SoulCycle, Middlesex Health productivity". TechTarget. Retrieved February 16, 2020.
  72. ^"Google launches Chrome Enterprise Grab and Go, a Chromebook loaner program for businesses". July 17, 2018.
  73. ^Krawczyk, Konrad (February 6, 2014). "Google reveals $1,000 Asus Chromebox for business videoconferencing".
  74. ^Sengupta, Caesar (February 6, 2014). "Chromebox, now for simpler and better meetings".
  75. ^"Chromebase for meetings makes video-conferencing personal and simple". March 31, 2016.
  76. ^October 2019, Joe Osborne 15 (January 26, 2021). "Google Pixelbook Go release date, price and features". TechRadar.
  77. ^Seifert, Dan (August 10, 2021). "HP announces new detachable and all-in-one Chrome OS computers". The Verge. Retrieved August 16, 2021.
  78. ^Tracy, Phillip (August 26, 2019). "Watch Out, Windows: Dell Releases First Chromebook Enterprise Laptops". LaptopMag.
  79. ^Warren, Tom (August 26, 2019). "Google and Dell team up to take on Microsoft with Chromebook Enterprise laptops". The Verge.
  80. ^"Dell's and Google's new Chromebook Enterprise laptops pack a built-in security chip". August 26, 2019.
  81. ^Tofel, Kevin C. (April 11, 2019). "Acer debuts a pair of durable Chromebooks for the enterprise, starting at $499".
  82. ^Nishida, Yuuki (June 4, 2019). "IT wary of Windows 10 adoption despite approaching deadline". TechTarget. Retrieved February 15, 2020.
  83. ^"AOPEN collaborating with Google on new retail technology". AOPEN. Retrieved March 11, 2015.
  84. ^Martonik, Andrew (November 17, 2015). "Google and ASUS officially launch the Chromebit, available now for just $85". Android Central. Retrieved January 30, 2016.
  85. ^Kastrenakes, Jacob (March 26, 2018). "The first Chrome OS tablet is here". The Verge. Retrieved August 26, 2021.
  86. ^Timothy (January 13, 2021). "Can You Use Multiple Monitors with a Chromebook?". Retrieved August 16, 2021.
  87. ^"Auto Update policy - Google Chrome Enterprise Help". January 17, 2020. Retrieved January 17, 2020.
  88. ^"Why Google plans to stop supporting your Chromebook after five years". PCWorld. August 22, 2016. Retrieved January 17, 2020.
  89. ^"Google announces 8 years of Chrome OS software updates for all new Chromebooks". January 21, 2020. Retrieved February 24, 2020.
  90. ^"How To Find Your Chromebook's End-of-Life Date". Lifehacker.
  91. ^Vaughan-Nichols, Steven (June 18, 2012). "It's 2016, and Chrome OS is ascendant". Computerworld. Retrieved September 7, 2013.
  92. ^Enderle, Rob (May 12, 2011). "Why Google's Chromebooks are born to lose". Digital Trends. Retrieved September 7, 2013.
  93. ^"Packaged Apps - Google Chrome". Retrieved January 26, 2016.
  94. ^"What Are Chrome Apps? - Google Chrome". Retrieved January 26, 2016.
  95. ^"ARC Welder".
  96. ^Amadeo, Ron (September 11, 2014). "Chrome OS can now run Android apps, no porting required". Ars Technica. Retrieved January 26, 2016.
  97. ^Klosowski, Thorin (September 22, 2016). "The Google Play Store Is Now Available in Chrome OS, Brings Android Apps to Your Chromebook". LifeHacker.
  98. ^Protalinski, Emil (May 8, 2018). "Chrome OS is getting Linux app support". VentureBeat.
  99. ^Raymond, Phillip (October 15, 2018). "Chrome OS Stable Channel Gets Linux Apps".
  100. ^"Linux on Chromebooks is finally coming out of beta with Chrome OS 91". Android Central
Chrome OS Terminal

More devices.
New audiences.
Real results.

Deliver rich, engaging experiences to more people by adapting your Android and web apps for Chromebooks. With a few changes to your existing app, you can reach new audiences on different formats and devices — anytime, anywhere.

Start building with information and tools for Chrome OS

Discover resources to start building your Android apps, web apps, and games for Chrome OS.

Learn about publishing your apps on the Google Play Store and engage millions of users on Chromebooks.

Use Chrome OS to develop apps in a fast, secure, and hassle-free environment.

Bring ideas to life with Linux on Chrome OS

Linux on Chrome OS gives you the power to use a single machine to build and run Android, Web, and Linux apps using your favorite editors, IDES, and world-class devs tools. Just set up Linux on Chrome OS to start building.

Start with Linux⁠

Jumpstart your latest project with design resources for Chrome OS

Find everything you need to know about designing your app for and on Chrome OS with app guidelines including information on user experience, visual design, UI components, navigation, fonts, and more.

See design resources⁠
Featured story

Gameloft races to 9X more revenue by optimizing for Chrome OS

When Gameloft optimized for Chromebooks, their game Asphalt 8 saw a 6× increase in daily app users and a nearly 9× boost in their Chrome OS app revenue.

Read more⁠

Chrome OS developer news and updates straight to your inbox

Find the latest news, tips, releases, updates, and more on Chrome OS.


Similar news:

We made a mutual massage in good faith. He also knew, but his specific techniques. He did yoga for a long time and his massage was from this series. We constantly kissed. It was extreme after three years of my celibacy, and in general, until this evening, I rarely kissed anyone, and it was.

6306 6307 6308 6309 6310