If you don't care about Verified Boot, you can install ChromeOS-Flex on a Framework Linux device (https://www.reddit.com/r/framework/comments/um0mk6/chromeos_...)
On the other hand, installing Linux on Chromebook hardware is straightforward.
The options are:
1. Use the Debian Linux VM (Crostini) that is already present on Chromebooks:
All you do is click on a few buttons in the settings. This approach preserves Verified Boot.
If you want to replace ChromeOS on a Chromebook with a Linux distro, you can use Crouton: https://github.com/dnschneid/crouton
This approach removes verified boot.
1. https://www.chromium.org/chromium-os/chromiumos-design-docs/...
For hardware and system's security QubesOS(i) is superb for isolation at the (virtual)machine layer. This talk(ii) from Micah Lee when 4.0 launched is a great overview/preview. It's my daily driver, and I find it indispensable.
For software security any standard linux distro you can utilize encrypted chroots(iii). This is how things like crouton(iv) work on ChromiumOS.
For library isolation you could utilise virtual environments like virtualenv for python. ( or nodenv(v) for 'Node libraries')
(ii) https://www.youtube.com/watch?v=f4U8YbXKwog
(iii) https://linux.die.net/man/1/chroot
ChromeOS is fine for web development, except that it started killing tabs after you open ten or more. I liked Cloud9 for the most part, particularly that it saved its state all the time: you could close your browser window, and come back to that project a few days later, and all of the same files would be open, and any terminal commands still running.
Both NetBeans and Atom were painfully slow, regardless of system configuration.
Switching to a docker-centric (i.e. HDD-heavy) workflow has meant switching to a remote server -- for now, a VPS, at least until I get my local server a new HDD. So ChromeOS is perfect for my needs, in that it has a full-color terminal with ssh, and a web browser for documentation. However, that's kind of a low bar. On the plus side, ChromeOS is quite secure. On the minus side, it's not "real" Linux in some relevant senses. Auto-updating is nice, and also being able to unbox a new machine, sign in, and automatically have your local apps and files start appearing. Heavy Google Apps integration is probably more of a feature than not. However, the rate at which the OS would kill tabs (including the terminal!) made the system quite unpleasant to use. Yes, the problem here is me: the hardware can't easily handle a large number of tabs, and it's a perfectly valid decision to kill tabs quickly rather than let the system become unresponsive. Probably it was even mostly effective at that. Probably a better-spec'd machine would have fewer memory issues. However, I have consistently gone to considerable lengths to avoid using ChromeOS: replacing the firmware requires disassembly and the removal of an internal screw, and risks bricking the machine. Enabling developer mode prevents the system from booting normally: instead, a white screen appears after power-on which says something like "Press spacebar to restore ChromeOS". I believe that it does let you know that this will wipe the user partition, after you've started. It does not tell you the key combination required to boot the machine. Loaning out a Chromebook in developer mode is therefore not recommended.
I'm shopping for a replacement for the chromebook I'm typing this on. It cost $115, I've used it for a couple years, the second power cord seems to be giving up, and the screen is partially held together with electrical tape: I think it gives it a bit of character. I've had at least two other (cheap) Chromebooks before this. I don't think I'm in the market for another. At the moment, I'm probably looking for a (Linux) Dell XPS 13, or similar: I would appreciate any suggestions.
[0] https://galliumos.org/
[1] https://github.com/dnschneid/crouton
[2] https://github.com/dnschneid/crouton#what-about-dem-crostinis-though
[3] https://spacevim.org/That said, I've been doing light webdev work on a Chromebook using Crouton (to run desktop Linux alongside ChromeOS, with seamless switching) and aside from difficulties with the MicroSD slot and apt-get on Ubuntu it's been quite nice. Getting solid, first-party Linux desktop app support would make Chromebooks a serious contender in the "cheap dev laptop for light work" space, and I think Google is working toward that.
Obviously, the hardware is going to preclude you from doing any serious heavy lifting, but I'm pretty excited to see what they come up with in another year or two. The battery life on these things is fantastic, plus some of them can also run Android apps.
Crouton installation instructions can be found here: https://github.com/dnschneid/crouton
A tip: while you can find ARM distributions of Linux distros and packages, it'll make your life much easier to get a Chromebook with an x86 processor.
So how can a text-editor that is not even an IDE require more resources...
[0] https://aws.amazon.com/cloud9/ [1] https://github.com/dnschneid/crouton [2] https://galliumos.org/
(I have no affiliation with any companies or projects mentioned.)
Here's the repo for crouton. I don't know if they have hardware support for pixelbook yet. https://github.com/dnschneid/crouton
I had some hardware/software issues from time to time but they were resolved with OS updates or a powerwash. My set up was ok but not ideal - it would fluctuate between bliss and frustration. Opening your laptop to find half of your led screen dark is not fun. Sometimes the laptop would simply poweroff - though this may have been an issue with regards to overheating. This is the price to pay to go into dev mode.
Other than the points above I think using a chromebook pixel for development has been a ok experience. For simple tasks my experience is very good. My battery life is still very good after 2 years. The screen is perfect. Switching between xfce and my other tabs is a breeze, I would have my xfce instance open in one tab, and have a few chroot instances open in another tab (think of the feel like python's venv).
If google staff is here, please answer my only question: is there any plans to make this set up more friendly for dev set ups?
My setup:
* Chromebook Pixel 2 in dev mode
* Crouton (https://github.com/dnschneid/crouton/) running CLI-only Debian stretch
* Google's SSH app (https://chrome.google.com/webstore/detail/secure-shell/pnhec...)
* Tmux running with NeoVim, cmus for music
My dotfiles and setup scripts are all here: https://github.com/fortes/dotfiles
Overall, I like this better than the old mac setup I have. Being in dev mode (and having to enter crouton chroot once per boot) aren't ideal, but I've gotten used to it. I'm hoping that maybe we'll get first class support soon though ( https://www.reddit.com/r/chromeos/comments/742f8j/how_chrome... )
[0] https://github.com/dnschneid/crouton [1] http://galliumos.org/
[1] https://github.com/dnschneid/crouton [2] https://github.com/drinkcat/chroagh
Oh yeah, Apple? https://news.ycombinator.com/item?id=13511241
If you're in developer mode (a one time key combo at boot, or a hardware switch under a cover on older machines), you can just ctrl-alt-T and 'shell' and you're in bash w/ the ability to sudo. If you want a more complete userland, crouton[1] will bootstrap an ubuntu setup in a chroot and you can apt-get away, plus it will give you X11 and some integration between that and the native chromeos stuff.
I've used a couple chromebooks as my primary laptop doing dev work for ~5 years now. The only time I ever carry a bigger machine is if I have specific tasks that need really big chunks of memory and/or disk.
Download crouton.
Create a chroot on the local device based on Ubuntu 14.04 (Trusty Tahr).
Install Visual Studio Code into the chroot.
Install git into the chroot.
It's also worth noting that putting your Chromebook into Developer Mode will wipe the device, so if you decide to do this, make sure all your local files are backed up first.
As far as switching to linux rather than run under Chrome OS, I guess that depends on what you mean. Include "xiwi" as one of your components when installing crouton, and you can launch android studio and have it run within the chroot, but display as a window on your chromeOS desktop. Its not visually attractive but functionally i'd say its very well integrated. It 'feels' likes its running directly on chromeos.
Sorry I can't recommend any particular link aside from https://github.com/dnschneid/crouton, but I think its worth a bit of googling to find discussions relevant to any questions you may still have.
But if you are a bit confident in your Linux skills, then I would recommend looking into Crouton [1], which allows you to easily access a fully functional Linux. I'm not sure what you're after, but this is what I use, and it satisfies all my needs. [I mean, it's just a Linux laptop, but that's what I need].
It lets me run ChromeOS most of the time, and then fire up an Ubuntu session when needed.
I don't know about you but I want my sysadmin to work for me so that when I tell it to shut up and get out of my way, it does exactly that.
[1] https://www.chromium.org/chromium-os/poking-around-your-chro... [2] https://github.com/dnschneid/crouton [3] https://www.chromium.org/chromium-os/developer-guide
I ordered the LS pixel, and it was by far the nicest computer I've ever used. I used IntelliJ IDEA in a popup window with zero lag for Java development. After enabling a kernel flag, VirtualBox worked too (with several networking caveats), and thereby Docker.
Ultimately I returned it and got the entry level MBP retina for the same price. Relying on crouton for functionality, meant small stuff would break here or there, much like running Arch Linux. For example, the home, end, page up/page down shortcuts broke in xiwi windows after an update. VirtualBox would cold cut the power to the machine if I enabled bridged networking. 64 GB is exactly half the minimum hd space I need. Developer mode is not a first class citizen within the OS, so I was constantly fighting the machine to get a stable work environment. Etc.
I really really miss it though. Especially the touch screen. It felt like using my future computer today. I needed a dev machine that I could rely on, and my current situation could not justify a $1300 toy. The ecosystem is rapidly evolving, and I am certain I will eventually be using something very much like the Pixel within a couple years. Hope that helps.
As for replacing your ubuntu machine, the default distro is 12.04, but I'm sure you can install the latest.
I don't know about the amount of shell tabs you can have (as I use tmux), but my short experiment seems to hold up well.
The only problems I think you'll face is the scary 'OS Verification' at startup and limited memory (but can be solved by using a SD card). croutons are cheap to install so install, remove, install until you find your niche.
Personally I develop on a Chromebook by SSH-ing into a Digital Ocean server direct from Chrome OS. I don't use it full-time as a dev box though.
It is, with Crouton. https://github.com/dnschneid/crouton
Or to be more precise, run the two concurrently.
If you'd rather blow away ChromeOS and install Ubuntu, it's just a few commands on the command line to boot from USB and install Ubuntu.
ChromeOS supports every common media format you'll come across.[1]
[0]https://github.com/dnschneid/crouton [1]http://www.chromium.org/audio-video
This does sidestep some of the security features of the device, but it's fine if you really want it. Or you can just ssh somewhere.
Crouton is a install script that uses a chroot to install Ubuntu through the shell on ChromeOS. You still need to enable developer mode, and it uses the ChromeOS kernel, but other than that it looks and feels like a "normal" Ubuntu installation.
What I use personally is a Chromebook. Yes, it is Chrome OS, but I've been doing all of my tutorials and basic apps this way and I really enjoy it.
You will need to look into Crouton which establishes a chroot of a Linux environment: https://github.com/dnschneid/crouton. Once you have this all set up, you can just run the Linux environment as a shell prompt. This allows you to use a text editor such as Caret (great free sublime clone that works as an extension), and test your app locally on ChromeOS.
This post was very helpful in getting started up: https://medium.com/on-coding/setup-a-complete-local-developm...
For example, within the chrome tab that includes my Linux terminal, I can run 'rails new sampleapp', then 'rails s' and open up localhost:3000 where my local rails app displays. I can modify the project directory in caret and push to git using again the Linux terminal. Sorry if I rambled on, I just really enjoy that setup on a $200 laptop.
EDIT: Link to crouton: https://github.com/dnschneid/crouton
And you don't have to "waste a lot of time". Crouton (https://github.com/dnschneid/crouton) makes setting up and using a chrooted Ubuntu incredibly simple and straightforward, and there are other easy ways as well.
I haven't run into any problems using it this way that many other people seem to have. Judging from online forums, many people install a chroot, Unity, and then everything falls apart for them because Dropbox/Sublime Text/something isn't ARM compatible. Sticking with just a browser and a CLI has made development on the Chromebook simple.
https://github.com/dnschneid/crouton
"Anyone who wants to run straight Linux on their Chromium OS device, and doesn't care about physical security. You're also better off having some knowledge of Linux tools and the command line in case things go funny, but it's not strictly necessary."
The bit about physical security seems to refer to the fact that for some reason you can't even password protect your machine.
If you're unsure whether or not a Chromebook is the right system for you, check out the specs[0]. Note that the Chromebook isn't extremely powerful, but that is not the product's goal.
Back to Ubuntu/Chrome: Rather than install Unity (which I actually don't mind on some systems), I opted for the actual crouton dev team's recommendation of XFCE[1].
XFCE is made for an underwhelming environment, and its performance is better than what Unity would probably offer.
You can in fact switch between Chrome-os/Ubuntu with 3 or 4 key presses, depending on your chromebook model. Your install likely won't come with vim, git, etc. installed as ujeezy noted, but if you're familiar with gnu/linux, you already know you what you want from your environment.
I, like many of you, have a couple of computers to lug around: Work laptop (windows), Macbook (expensive shiny development tool). Being that I really have come to enjoy the macbook's battery life, even when using lots of high-resource tools/windows, I'm not sure where this chromebook will fit in. Breaking my macbook scares me, but so does being without it.
If you have a chromebook, definitely try this out. I was expecting to have to deal with lots of issues, but the install was extremely smooth (other than the downloads coming in at 20-30kb/s).
Things to note:
* Make sure you read Crouton[1]'s readme - there are a few potential 'gotcha's in there.
* Disable XFCE or Unity's screensaver.
* As ujeezy noted, you'll need to install vim/emacs, git, gcc, etc.
* While nice, and amazing for what it is, this will probably not replace your default dev environment, unless you exclusively use programs that aren't resource intensive, and/or only exist in terminal.
[0] http://www.google.com/intl/en/chrome/devices/samsung-chromeb...
To get X I hacked together a Chrome App[0] VNC client, based on noVNC. It's a bit laggy sometimes, but does the job for my purposes.
Ron Minnich (of Coreboot fame) wrote a guide for doing the same with Arch[1]. And there's Crouton[2] for Ubuntu, but I'm not sure whether it does ARM or not.
[0] https://bitbucket.org/saljam/vnc
[1] https://docs.google.com/document/d/1IVABFl9TJMFPqoE_c0vWP7Yh...