Who are we?

This Is a Young and Still Developing Project of Porting The Chromium OS To The Raspberry Pi 2 And Other Single Board Computers, it is run by a small team, Dylan Callahan, Hans-Gerhard Weinreich and Stephen Bonnell. So Far we Have had four successful releases of our ChromiunRPI port which is a ChromiumOS built for the raspberry pi 2. We plan on expanding our devices and our releases to other Single Board Computers.

We started on Reddit, and while you can still ask support questions at https://www.reddit.com/r/ChromiumRPI/

We are Hoping To Become Our Own Community, Our Goal is that this project can grow to support the rapidly growing amount of Single Board Computers.

So feel free to sign up for our newsletter or even sign up and share your idea's and thoughts on our Forum.

This Project has Only been around since December 8th of 2015, so far its been a great journey and we hope that you decide to contribute and enjoy the releases.

Thank You for everyone that has followed and supported this project.

EMAIL

Project Leader / Developer

Dylan Callahan

tohipfortheroom@gmail.com

Lead Developer

Hans-Gerhard Weinreich

haggster82@yahoo.com

Public Relations / Marketing

Stephen Bonnell

smbonn2005@hotmail.com

Location

Around The World

News

March 2, 2016

We are happy to confirm that ChromiumRPI is working and available for download for the Raspberry Pi 3. The image is identical to the Raspberry Pi 2 v0.4 image and can be downloaded via the link referenced in the Downloads section. 

Supported Hardware

The Raspberry Pi 2 $35

The Raspberry Pi 3 $35

The PI Zero $5 - Development Coming Soon

The C.H.I.P $9 - Development Coming Soon

The Pine64 $15 - Development Coming Later This Year

Forum

What Is Chromium OS?

Chromium OS is an open-source project that aims to build an operating system that provides a fast, simple, and more secure computing experience for people who spend most of their time on the web

CHROMIUMRPI2 0.4 Release Notes

This release contains improvements in various different areas: 

Performance:
- we have switched to the Ondemand governor which puts an end to the previous situation in which we constantly locked the CPU to a fixed clock speed. Since the CPU frequency will NOT permanently be set to the lowest or highest frequency, we are able to safely profit from the benefits of a slight overclocking from previously 900MHz to now 1GHz on all cores. This is an effective 10% performance boost in theoretical computing power and the benefits of this can be observed during CPU intensive tasks. Expect an overall speedup.
- since the RaspberryPi2 only contains four cores with a single thread on each core and the CPUs do not achieve the performance of other current ChromeOS/Chromium OS devices, we have decided to switch from the standard Linux CFS kernel scheduler to the -gc scheduler branch which is maintained by Albert Chen ( http://cchalpha.blogspot.com ) and which is a modification of the BFS scheduler. This scheduler is optimized for desktop systems, focusing on extremely low latency for UI and related tasks.
- boot performance: switched to the LZ4 for kernel compression, which is the fastest available kernel compression algorithm, in order to increase the speed of the boot process
- several other kernel related tweaks, mainly focused on improving latency, interactivity and some first attempts of trimming down the kernel size (currently we are still building modules for a variety of hardware that the RasPi supports, but for which there is no real use-case under Chromium OS; some of this has been removed and the process is ongoing) 

Storage:
- we have switched over from the standard CFQ i/o-scheduler to BFQ which results in slight storage read/write access latency improvements. Since we are using flash storage, those improvements will not be as extreme as if we were using HDDs, but this should still improve latency under several conditions (BFQ will replace CFQ in upcoming Linux kernels anyway)
- mounting all partitions without atime: Since our OS operates on slow microSD-card flash storage, we need to ensure that there are as few i/o-related bottlenecks as possible. Due to this we decided to turn off the atime file access time-stamps which results in less i/o operations on the sdcard
- the system will perform a trim operation on the stateful partition on roughly every fifth boot in order to avoid speed degradation of the flash storage. While not being as effective as on e.g. SSDs, using trim on simple sd-cards will still result in speedier write operations after trim has been executed
- increased the available free storage on the stateful partition: previously, only around 200MB of free storage space was available per user. This has been increased to 2GB which should be sufficient for most people

UX:
- Google APIs are built-in, so no manual steps are required before being able to log into your Google account
- automatic time synchronization on boot: No manual steps are required in order to set the time, as it will now been synced automatically as soon as the system boots. Since the time is being synchronized over the network, internet connectivity must be guaranteed during boot
- zram is activated per default: As on all proper ChromeOS devices, the system now uses zram. The compression ratio is roughly 3:1 so a user will be able to open three times as many tabs as on V0.3 before the LMK is being triggered. The compression algorithm is LZ4 which ensures that the impact on the CPU will be as slight as possible when reading/writing to zram
- improved stability: R49 is now stable, whereas the R49 release that V0.3 was based on was still in development. Therefore, this build is officially based on stable sources 

Known issues:
- Netflix doesn't work (don't ask)
- This build is for systems using Ethernet, as the RasPi doesn't contain a Wi-Fi module and those are an optional accessory. Kindly refer to our separate guide in order to enable Wi-Fi, which might or might not work with your adapter
- Low-Fi TVs and TVs with resolutions lower than Full-HD might not work with this. This is being developed on 1080p screens which will also show a verified resolution of 1920x1080. TVs with lower resolutions often don't work at all, sorry about that
- Regarding the above: We do not use any boot splash screens: if you get a black screen for more than one minute, you are most likely using an incompatible TV. The boot process only takes a couple of seconds, so there is no need waiting for longer than roughly a minute for it to boot
- YouTube 4K HFR videos don't run perfectly without stutters: The RaspberryPi2 might be the wrong device for this (HD videos in full screen are now running smoothly for the most part, while still showing the occasional stutter)
- If you don't ensure you can connect to the Internet, then you won't have the date/time set automatically: This is not a bug, this is just a reminder in order to guarantee that you are connected via Ethernet when turning the device on, in case you do not want to manually set the time
- The image doesn't use all the space you have available on your microSD card: We have already increased the available size to 2GB of free space that is available to the user. Since we cannot afford to offer 16 or 32GB images for download and automatic resizing is technically not possible at this stage, you have the option to manually resize the relevant partition via modifying the image on a Linux-based system if you need more space than 2GB
- Automatic screen rotation doesn't work

Compiling Instructions Chromium OS for Raspberry Pi 2

Initial notes:

• Don't expect to build this and have it work perfectly on a Raspberry Pi, it's a work-in-progress
• This guide will be much easier to follow if you've built Chromium OS before for another platform. If you've having trouble following it, try following the developer guide (linked before) to build an x86-generic image first, and then come back.
• If you want to help out, find us in #ChromiumRPI on Freenode IRC, submit a pull request or message us on reddit.com/r/ChromiumRPI

Prerequisites:

To get started, make sure you have the following:

• a 64-bit build machine, running Ubuntu version 15.04 or 14.04 (better running headless. Other versions/distros might work)
• an account with sudo access
• at least 6GB of RAM (linking Chromium uses about 4GB of your RAM at the same time, so this is another reason not to run any UI or X server in the background if you want to avoid extremely slow builds)
• a fast Internet connection - you'll need to download several gigabytes of source code, if your connection is slow, that won't be fun, especially if you need to re-sync the repo
• sufficient amount of free disk space: 60GB should be the absolute minimum and even with that you could run into problems, 100GB of free space or more is recommended

To give you an idea of how long it takes to complete a build:

• ~10 to 12 hours on a dual core, 4 thread Core i5 Haswell (2014) CPU based machine with SSD and 8GB of RAM
• ~24 hours on lower end (though not Atom based) laptops with a dual core CPU and 6GB of RAM
• a build server (read: non-laptop) with several cores based on current CPU design and at least 16GB RAM is rumored to be able to complete a build within ~2 hours

Get the code:

First, you'll need to download the Chromium OS source code. To learn do so, and also how to setup your environment, check out this link: http://www.chromium.org/chromium-os/developer-guide

Please be aware that you are syncing the bleeding edge source code which can be considered "alpha" when using the instructions given within the developer guide. If you want to be sure to avoid any potential issues during your build process, you will need to check out one of the stable branches. The following example shows how to check out a stable branch - in this case R49, which was the current stable branch at the time of writing:

repo init -u https://chromium.googlesource.com/chromiumos/manifest.git -b release-R49-7834.B
repo sync

You can open the URL https://chromium.googlesource.com/chromiumos/manifest.git/+refs in any browser and check the branches which start with "release-R". Finding out what the current stable ChromeOS release is, shouldn't be difficult (for example, you could just google it, or check the version information on your Chromebook running on the stable channel, if you own one) - once you have found out what the current ChromeOS stable version is, just use the corresponding "release-" branch from that list in order to be sure you're checking out the latest stable code.

Once you've downloaded the code and you've reached the "4.3 Select a board" step, continue below.

Add the overlay:

The raspberrypi overlay is already part of ChromiumOS, although it does not build X or Chromium.

To build for the RaspberryPi2B, you'll need to use the raspberrypi2 overlay provided by this repo. Until this is merged upstream into the Chromium OS project, you'll have to copy it manually across.

Find the folder named "overlays" in the "src" folder of the code you checked out. You'll see a number of folders with names starting "overlay-". Place the overlay-raspberrypi2 folder in this folder alongside the other overlays.

Board setup:

You only need to run this once (unless you nuke the chroot):

./setup_board --board=raspberrypi2

If you want to re-create the board root, run:

./setup_board --board=raspberrypi2 --force

You'll probably want to set the "backdoor" password for a development image to let yourself into a shell when the UI isn't working, to do that, use the following command:

./set_shared_user_password.sh

Once prompted, enter a password, then press enter. As above, you only need to do this once.

Patching:

Add "raspberrypi2" to ~/chromiumos/src/third_party/chromiumos-overlay/eclass/cros-board.eclass

Building an image:

Before we can build an image, we need to build all the required packages. Enter the following command to build those (and pray everything compiles):

./build_packages --board=raspberrypi2 --withdev --nowithdebug --nowithtest --nowithautotest

Go get a nice cup of tea, and maybe read a book.

Once all the packages have been successfully built, we can build a USB image by running the following command:

./build_image dev --board=raspberrypi2 --noenable_rootfs_verification

Rebuilding:

According to our experience, building the whole system again after a failed build attempt leads to all kinds of issues, even if the chroot is re-created. Therefore I actually recommend to resync the repo and create the chroot again in case you are about to build the system again: ensure that you first delete the chroot cleanly via cros_sdk --delete within the ~/chromiumos directory. After that you can delete the chromiumos directory via rm -rf.

chromiumos # cros_sdk --delete
chromiumos # cd ..
~ # rm -rf chromiumos

Our official IRC channel is #ChromiumRPI on Freenode. We can't guarantee we'll be there at all times, but feel free to join and if you can catch us, ask us anything.