What does HackerNews think of crouton?

Chromium OS Universal Chroot Environment

Language: Shell

#1 in Linux
#1 in Shell
#1 in Ubuntu
It's the other way around. If you want ChromeOS (in particular with its Verified Boot system for the OS image [1]), you need special hardware that comes with Chromebooks, including the Framework Chromebook. That has nothing to do with the ability to run Linux, though.

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/...

I'm guessing GP means natively, not in a VM. I've been super grateful for the VM-based method, but I still prefer the native experience like that provided by Crouton[1]. With Crouton being "maintenance-only" now I share GP's hope that a similar thing will be possible and easy.

[1]: https://github.com/dnschneid/crouton

In order of decreasing isolation:

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')

(i) https://www.qubes-os.org/

(ii) https://www.youtube.com/watch?v=f4U8YbXKwog

(iii) https://linux.die.net/man/1/chroot

(iv) https://github.com/dnschneid/crouton

(v) https://pypi.org/project/nodeenv/

To be clear, chromebooks have for a few years been able to be regular labtops since crouton [1] allowed installing linux distros on them. (And could even use wine to run windows games on the x86 chromebooks.)

[1] https://github.com/dnschneid/crouton

I patched my firmware and installed GalliumOS[0], which is basically a tweaked version of Ubuntu. I was previously using crouton[1], which functions similarly[3] to Crostini. On ChromeOS, I was using the Cloud9 Web IDE (which has since become an Amazon service), and on the Crouton/GalliumOS side of things I've been using ST2/3, but have essentially switched completely to SpaceVim[3].

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/
I don't own a chromebook, but have you tried [0]? Looks like it allows to run linux programs fairly easily.

[0] https://github.com/dnschneid/crouton

ChromeOS utilises the Linux kernel itself but without arguing semantics you can install a chroot Linux distribution with Crouton [1]. Whether that supports this specific machine (whatever it may be) I do not know.

[1] https://github.com/dnschneid/crouton

Google is working on making Chromebooks more developer-friendly. Some of them support running full desktop Linux apps now, but it's still in the experimental stages and I wouldn't recommend buying one for that specific feature until it's more mature.

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.

And people claimed that Eclipse was bloated. Yet I was able to run 5 years ago not one but 2 Eclipse instances on an ARM Chromebook with 2GB of memory compiling and debugging an Eclipse extension. This was in a crouton chroot [1] with few chrome tabs opened in parallel. When I edited the files that involved using a lot of IDE features for Java the system was snappy. The only time when I felt that the system was slow was when rebuilding everything. But that was expected given the slowness of CPU and RAM.

So how can a text-editor that is not even an IDE require more resources...

[1] https://github.com/dnschneid/crouton

I have a $300 (plus SSD price) Dell Chromebook 13 from a few years ago which I use https://github.com/dnschneid/crouton on to run Ubuntu with i3. It's a wonderful machine for light web dev (I've never tried any really stressful development, I use my fuller spec'ed laptop for that). Great battery life, light, best keyboard I've used. I don't know how well it would work for 'serious' development depending on your field, but it's probably the best starter laptop for programming I could possibly imagine.
If you need a complete IDE on a chromebook, you might check out Cloud9[0], which seems to have been acquired by Amazon. It gives you a decent editor and a small VM as a workspace, and the nice thing is that you can close the browser window and do something else, and the workspace will be exactly as you left it when you return, including any running terminal commands. I used C9 for a while before discovering Crouton[1] and subsequently GalliumOS[2], and it's still a pretty credible alternative to local development.

[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.)

In my experience, Chrome OS is absolutely usable as a development machine for linux environments with crouton[1]. Crouton basically installs Ubuntu within Chrome OS, and can include GUIs and tons of software packages. I've done nearly the entirety of my WGU IT degree using Chrome OS, and if I get a software development degree, I'll use it there too. If Windows interoperability or virtualization is required, then you might look elsewhere, because virtualization is tough to set up in the chroot environment and would run sluggishly anyway if you use an ARM-based laptop like I do.

[1] https://github.com/dnschneid/crouton

On my chromebook I use crouton[1], which is arguably more "native". You get an Ubuntu install in a chroot and can even run X11 apps in a chrome window. I was even able to compile neovim, you just need to set it up to use the system's lua and luarocks.

[1] https://github.com/dnschneid/crouton

I am not google staff member but I am a dev who uses a chromebook pixel at home. This Nov will be 2 years since I first received my chromebook pixel. Here is my set up: 1) I unlocked machine, put it in into dev mode 2) crouton set up to use xfce 3) ssh to remote servers to use things like docker

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?

Yes, been using it as my primary development machine for the last two years. I work on a large Node / React codebase, and occasionally do design work.

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... )

Crouton[0] is one option for that, but I would recommend GalliumOS[1] to anyone interested in a Chromebook. My current laptop is an Acer C720, purchased for $110 and running GalliumOS. It's not shiny or new, but it gets the job done, and it's practically cheap enough to be disposable. There are admittedly times when I wish I could justify the cost of a Pixel or an XPS 13, but I can't really get past the idea of being able to buy a half-dozen other machines for the same price.

[0] https://github.com/dnschneid/crouton [1] http://galliumos.org/

The Chromebook 'powerwash' seems to fulfill this requirement nicely[1] - you can even let students drop the machine into Developer mode, play with Crouton[2] and so on, and if (when) things go wrong, poof, a single chord at startup and you're back. 1: https://support.google.com/chromebook/answer/183084?hl=en 2: https://github.com/dnschneid/crouton
If you're willing to put your Chromebook in dev-mode, it doesn't necessairily have to be a remote IDE. You could also use a Linux distro from within a chroot [1][2].

[1] https://github.com/dnschneid/crouton [2] https://github.com/drinkcat/chroagh

I'm in the same boat but opted for ChromeOS with Linux https://github.com/dnschneid/crouton on https://www.groupon.com/deals/gg-acer-116-chromebook-2857 My current mac mini sits idle only used for activities Chrome / linux doesn't support

Oh yeah, Apple? https://news.ycombinator.com/item?id=13511241

Chromebooks are actually great dev environments already --better than most of what I've seen on android.

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.

[1] https://github.com/dnschneid/crouton

"For Chromebooks" is rather misleading. It would be better titled, "For ARM-based Linux distros". The setup installation includes the following:

    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.
So it's not natively compiled for Chromebooks as a Chrome/Android app. Instead you're just installing crouton and then putting Ubuntu onto it. With all due respect to these guys, crouton has been around for some years[0]: I had it installed on my Samsung ARM Chromebook in 2012 and used it for coding.

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.

[0]: https://github.com/dnschneid/crouton

Crouton still requires you to root the chromebook, so you get the annoying white screen on every boot (unless you are willing to go farther and flash the firmware).

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.

The short answer is no.

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].

[1]: https://github.com/dnschneid/crouton

You can even get a full Ubuntu installation in a chroot very easily using a neat tool called Crouton[1]. Crouton lets you jump in and out of chromeos and ubuntu with a keyboard shortcut. I had a very good experience running crouton+ubuntu on my Acer c720, and I imagine it'd be even better on a higher powered computer


Have a look at https://github.com/dnschneid/crouton

It lets me run ChromeOS most of the time, and then fire up an Ubuntu session when needed.

Check out crouton (https://github.com/dnschneid/crouton). you can tab back and forth between chromeos and (l/x/k)ubuntu. Fully Atom-compatible
The comparison with ChromeOS is flawed because you can go into Dev mode[1] on ChromeOS and do whatever the heck you want in a linux userland. There's even a project called Crouton[2] that allows you to install traditional Linux apps side-by-side on your Chromebook. You can also build ChromiumOS[3] the open-source version of ChromeOS and make it do whatever the heck you want.

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

If you use crouton [1] to manage chroots, you can easily run Sublime and everything else in Linux land. You should be aware of what developer mode is on Chrome OS, though, and all of the negatives that comes with it. The xiwi crouton target allows you to connect to the chroot in a popup window. You can also now launch individual applications giving an integrated experience, including copy/paste.

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.

[1] https://github.com/dnschneid/crouton

They have some great docs at https://github.com/dnschneid/crouton and the community's great at http://www.reddit.com/r/crouton

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.

Yes - https://github.com/dnschneid/crouton

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.

Crouton is essentially that 'official' way. It's maintained by a hardware engineer from Google. https://github.com/dnschneid/crouton
> I don't know if it's possible to replace ChromeOS for Linux...

It is, with Crouton. https://github.com/dnschneid/crouton

Or to be more precise, run the two concurrently.

It's really not though. There's crouton which makes it trivial to setup a chroot - https://github.com/dnschneid/crouton which is good enough for most users.

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.

It's completely simple to get a real terminal/SSH running with Crouton.[0]

ChromeOS supports every common media format you'll come across.[1]

[0]https://github.com/dnschneid/crouton [1]http://www.chromium.org/audio-video

If you want a full featured local linux command line, you can switch to developer mode and install one in a chroot via something like https://github.com/dnschneid/crouton

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.

I use Crouton [1] on my cheapo chromebook and it works pretty OK for lots of tasks. I mainly just watch youtube on that thing, so this solution works since I only occasionally want to hop on Linux to get some stuff done.

[1] https://github.com/dnschneid/crouton

Hacking Go from a Chromebook; definitely gonna look. Neat if it runs happily as a local server under crouton ( https://github.com/dnschneid/crouton ).

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.

Try out https://github.com/dnschneid/crouton and with that you can get Linux support on your Chromebook. Rest will fall in place.
Unless you develop specifically with Microsoft technologies, Chromebooks can easily be used by developers as well. You can easily dual boot or run crouton[0].

[0]: https://github.com/dnschneid/crouton

I'm in the same boat, currently teaching myself ruby/rails during lunch breaks from my job in the hopes of finding a better one.

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.

One option is to put the Chromebook in dev mode and use Crouton[^1] to install Ubuntu as a chroot. It's easy to do and works well. You can use ChromeOS as usual side by side.

[1]: https://github.com/dnschneid/crouton

@Downvoters: Please do your homework[0] before downvoting. If you genuinely think my comment deserved downvotes, at least afford me the courtesy of an explanation.

[0]: https://github.com/dnschneid/crouton

Crazy deal. I would buy one if I needed a new machine right now. Then I would use this: https://github.com/dnschneid/crouton
Chromebook Pixel is actually a really nice laptop that "just works". Even the touch screen has driver support. You can chroot Ubuntu, or, wipe and go all-in.

EDIT: Link to crouton: https://github.com/dnschneid/crouton

I'm using crouton to run ubuntu on my samsung chromebook. It works great and is very easy to install:


Are there that many $250 laptops with 6 hours of battery life?

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.

Honestly, the $250 ARM Chromebook is among the very best things you could do for development (in my opinion). I can use ChromeOS for when I'm not doing anything hardcore and then just open a chroot jail (via crouton https://github.com/dnschneid/crouton) with a full xubuntu/xmonad install when I really want to get cracking. Both open so quickly it's almost disorienting, either from start or from sleep. It's the same size and weight as a Macbook Air and the battery life is outstanding (I've come quite close to the 9 hr mark when I'm not listening to music on speakers). The only downside, at least for the purposes of this question, is that it isn't fully HD, or rather isn't 1080p which is what I assume the OP meant. Still, I'd say that this is by far the best computing investment I've ever made, and I'm happier with this than I am with the $1000 laptop I got 6 months ago.
Just in case anyone is interested: I haven't tried it, since I don't own a Chromebook, but Crouton (https://github.com/dnschneid/crouton) seems to do exactly what he's doing in the article, only automated.
I used a script called crouton[0] developed by a Googler to install an Ubuntu chroot. I get to use Chrome OS as my browser (and it's a very good browser) and I get a fully powered Linux instance to develop with locally in crosh (and it's a very good-looking shell). I use vim, but if you want a GUI, it's very easy to install your DE of choice, since it's the same as it would be as any other Ubuntu machine.

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.

[0]: https://github.com/dnschneid/crouton

Looks like this is 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.

Whoops, serves me right for not double-checking [2]: https://github.com/dnschneid/crouton
It's much easier to develop on a Chromebook than you probably think. There are many editor choices, there is Web Inspector for debugging, there is an SSH client (in NaCl), there is developer mode, there is Crouton which gives you a Ubuntu chroot without losing the rest of ChromeOS[1]. I don't do NaCl, so I can't speak to how much pain that is, but for web development I find Cloud9, Web Inspector, Secure Shell to be more than adequate.


Having just set this up, I'm really digging it.

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...

[1] https://github.com/dnschneid/crouton

A few commenters are asking about running their favourite distro on these. I've installed a Debian chroot on mine. I've been using it as my main machine for almost 2 months now. I'm quite happy with it, but I mostly use it as a terminal to bigger machines at the university.

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...

[2] https://github.com/dnschneid/crouton