ChromeOS is Linux with Google’s desktop environment | Hacker News Reader

ChromeOS is Linux with Google’s desktop environment

aboutchromebooks.com

137 pointsdevonnull188 comments

Google put in a ton of work to make all the Linux and Android sandboxing while still being able to do file sharing into the sandboxes, Wayland GUI app bridging, usb pass-through, and a bunch of other stuff.

https://chromium.googlesource.com/chromiumos/docs/+/HEAD/con...

ChromeOS got good and is wildly underrated for software development. ¯\_(ツ)_/¯

Do google developers develop on Chromebooks ?

All new devs are given Chromebooks unless they need a specific device (like a MacBook for iOS devs)

Are they still given a Debian workstation besides that? Didn't know they are dogfooding ChromeOS that seriously.

Nopes, everyone uses cloud VMs by default. These VMs were very powerful too.

Is gLinux[1] still a thing?

https://cloud.google.com/blog/topics/developers-practitioner...

Yes; that’s what’s used on the VMs, workstations, and Linux laptops.

But aren't devs also provided with: SSH, CI build minutes, and GCP budgets for containers and VMs?

To actually dogfood Chromebooks internally like Chromebooks for Education and for Families, Google would need to deny its devs containers behind a greyed out "Turn on Linux" button and deny them access to Colab notebooks and AI platform etc (while only allowing Play Store apps); nothing to SSH to, no notebooks, no devpod, no local git repos (!), no local terminal to run e.g. pytest tests with, no devtools JS console, etc.

I'm pretty sure the grayed out "Turn on Linux" button due to policy setting by the organization managing the Chromebook.

I don't follow? Software developers... aren't students or children.

It's a different market with different product segmentation and feature sets, it just happens to run on the same hardware and OS. And it's true that schools and parents often demand that their kids not hack stuff that the "admins" don't understand. And maybe that's bad or misguided or whatever. But it's not a statement about using a Chromebook as a developer client, which IMHO works very well.

The kids can't code locally on a git repo on Chromebooks and run make; they don't even have a terminal.

Googlers only code remotely on Chromebooks.

The kids MUST be able to run `pytest arithmetic.ipynb` on whichever platform.

(It was not appropriate for Google 2016-2020 (?) to decide that we should all accept WASM runtime vulnerabilities in sandboxed browser processes running as the same user instead of per-app SELinux contexts like Android requires since 4.4+, or instead of containers and VMs like almost all of Google's hosted apps and internal systems)

Cannot believe there's not even a JS console on these for the kids (because "Inspect Element" and "Turn on Linux" are blocked for them all)

I'm still not understanding the criticism. You're saying it's bad that kids can't hack on their school-supplied/parent-managed computers. And... I think I agree, as far as it goes.

But you're responding to a thread saying "Chromebooks are good for Developers", where's it's just not responsive. There's absolutely no reason schools or parents can't hand kids unmanaged/unrestricted Chromebooks; they just choose not to (for some good and some bad reasons). Take that up with schools and parents, I guess?

>There’s no reason schools or parents can’t hand kids unmanaged/unrestricted Chromebooks

Holy cow. Are you serious? Kids break stuff for fun.

This is basically a “You’re holding it wrong” argument. Schools are gonna have heavily managed chromebooks, because it’s the reality on the ground that they can hardly afford anything, much less insane IT support for every student. Like, kids are going to actively sabotage the software on their school equipment if they can as a way to avoid doing schoolwork. This was common when I was in high school over a decade ago, they solved it with Deep Freeze software and extremely restrictive Microsoft policies.

Google is the one with a wealth of IT and developer talent, not school systems. They are making the product, not the schools. Devs have to come from somewhere, and going out a limb here, I don’t think smartphones (the other computer that [low income] students are likely to have access to) provide an on ramp for developers, so it would be good if these chromebooks did.

Virtually any Linux distro can be turned into a managed OS.

Something could manage access to and the run state of containers (just like APKs and other apps running without `ps -Z`) so that the state of the machine can be reset.

And then an instructor could specify policy that would affect which apps and containers run on the machines attached to the management domain (e.g. at test-taking time and also all of the times)

Comparing etckeeper and rpm-ostree's diffs of /etc lately

(where e.g. LVM or btrfs CoW snapshots would need eventual compaction)

I think you are greatly over simplifying it

The relevant question is whether students are empowered to do actual STEM work (in git, with python, and notebooks and/or an actual IDE) in application of the K12CS Q12 STEM curricula.

There should be a specification of things that we need the computers we buy for the students to support; a rubric to consider in acquisitions and discussions with vendors attempting to solve for the needs of education and learning.

Seriously, compare the results of canned flash games (with metrics) vs locally coding math to do a scientific experiment or solve immediately-graded exercises with code.

I've reviewed the curated app catalogs here and TBH the tragic gap is perhaps at "how to computer math" [in notebooks in a version controlled (e.g. git) repo] [in Python [with JupyterLite or vscode.dev w/o devpod/codespaces [due to Chromebooks]]]; just a video of Arithmetic in notebooks instead of a calculator.

GeoGebra and Desmos are neat. Geogebra has a CAS (Computer Algebra System) built-in, but it's not Python with test assertions. And when the canned math app e.g. fails with weird complex exponents of e, it's a good idea to reach for Python (or Julia, or R, or) instead of only the apps in the Play Store.

Exercise: Install Git and Python (maybe in Termux from Fdroid) on a Chromebook, then run repo2podman {with a FamilyLink account,}

Exercise 2: Create a Jupyter Notebook on a Chromebook and save it to work on from home {with Gapps Edu and Family Link} when Colab isn't allowable and JupyterLite doesn't have a gdrive plugin yet.

Containers in a local devpod (~codespaces) VM for the students might solve.

This should also work on computers to support real-world STEM workflows:

  <alt-tab> make test
  make clean

  <alt-tab> <up arrow> <enter>

OK, you're simply having a different argument, and I frankly don't even disagree. "Schools should let kids run stuff in Crostini" is something I think we can both get behind.

But nonetheless schools don't (and never have, FWIW), and it's not the OS's fault that they use important and desirable manageability features to do it.

If schools could afford it, they would probably get value from GitHub/GitLab/Gitea for all students. And then would they get value by provisioning containers to grade students' code with Kubernetes (k8s) and GitHub/GitLab/Gitea?

Internally, Google has a huge git monorepo and gn and IIRC gerrit for code review (?) and externally many repos in various orgs on GitHub (some now contributed to e.g. the Linux Foundation's CNCF).

A Google Colab JupyterLite-edition could optionally integrate with Google Classroom.

There's an issue in a repo re: a JupyterLite gdrive extension and fs abstraction so that it would work with other non-git cloud storage providers.

vscode.dev supports git commit and git push from the browser tab to GitHub, which can then run the code with GitHub Actions. vscode.dev can also connect to GitHub Codespaces (or devpod). GitHub Codespaces spawns a container in GitHub's k8s cloud for interactive use with {VScode, Jupyter, and IIRC SSH} instead of batch headless use with logs like GitHub Actions.

You can write a simple git post-receive hook script in .git/config that runs a script on every push to the repo, and then later realize why each execution of a post-receive hook needs to run the job in an isolated container to prevent state leakage between invocations of the script; there should be process and data storage isolation for safe and secure GitOps.

Research institutions like e.g. CERN and ORNL have e.g. GitLab with k8s; there, pushing to a Pull Requests branch can cause a build to run the tests in a container auto-provisioned somewhere in the private cloud and report the results back to the Pull Request thread. UCBerkeley developed ottergrader (to succeed nbgrader and okpy) to grade Jupyter notebooks in containers (optionally with k8s, or locally) and post the scores to e.g. Canvas LMS.

Can the students grade their own work with containers in Crostini/Crouton//ARC without homomorpohic encryption (like Confidential Computing) running potentially signed but unknown code on their local workstations?

JupyterLite and vscode.dev+jupyter+pyodide work in Chrome on Chromebooks today, but it's really suboptimal from a mainframe-era perspective.

> gerrit for code review

Gerrit was deprecated a while ago.

The fact that they're managed isn't the problem, it's the type of restrictions that google is enabling. Both the schools and google are at fault.

You say "important and desirable manageability features" in your other comment and I strongly disagree. Disabling the web inspector is not important and it is the exact opposite of desirable.

Not exactly but the equivalent yes. Workstation and VMs. All tests and builds are basically run in borg by default.

For most Google developer developing on a Chromebook basically means running ssh and chrome remote desktop.

For students, unless there are allocated server resources with network access, it SHOULD/MUST scale down to one local offline ARM64 node (because school districts haven't afforded containers on a managed k8s cloud for students at scale fwiu, though universities do with e.g. JupyterHub and BinderHub [4] and Colab).

For Chromebook sysadmins, Instructors, and Students learning about how {Linux*, ChromiumOS, Android, Git, Bash, ZSH, Python, and e.g. PyData Tools supported by NumFOCUS} are developed, for example;

When you git commit to a git branch, and then `git push` that branch to GitHub, and create a Pull Request, GitHub Actions runs the (container,command) tasks defined in the YAML files in the .github/workflows/ directory of the repo; so `git push` to a PR branch runs the CI job and the results are written back as cards in the Pull Request thread on the GitHub Project; saving to the server runs the (container,command) Actions with that revision of the git repo.

Somewhat-equivalent GitOps CI Continuous Integration workflows (without Bazel or Blaze or gtest or gn, or GitHub Enterprise or GitHub Free due to the kids' intererests) that might be supported at least in analogue by Education and Chromebooks: k8s with podman-desktop in a VM, Gitea Actions (nektos/act; like Github Actions), devpod

devpod: https://github.com/loft-sh/devpod :

> Codespaces but open-source, client-only and unopinionated: Works with any IDE and lets you use any cloud, kubernetes or just localhost docker. (with devcontainer.json, like Github Codespaces)

devcontainer.json is supported by a number of tools; e.g. VScode, IntelliJ,: https://containers.dev/supporting

repo2docker has buildpacks (like Heroku and Google AppEngine).

repo2docker buildpacks should probably work with devcontainer.json too?

repo2docker docs > Usage > "REES: Reproducible Execution Environment" describes what all repo2docker will build a container from: https://repo2docker.readthedocs.io/en/latest/specification.h...

jupyterhub/repo2docker builds a Dockerfile (Containerfile) from git repo (or a Figshare/Zenodo DOI) that minimally has at least an /environment.yml and /example.py (and probably also at least a /README.md to start with), and installs a current, updated version of jupyter notebook along with whatever's in e.g. /environment.yml per the REES spec. [1][2][3]

[1] repo2docker/buildpacks/base.py: https://github.com/jupyterhub/repo2docker/blob/main/repo2doc...

[2] "Make base_image configurable" https://github.com/jupyterhub/repo2docker/commit/20b08152578...

[3] repo2docker/buildpacks/conda/environment.py-3.11.yml: https://github.com/jupyterhub/repo2docker/blob/main/repo2doc...

[4] "When to use [TLJH or Z2JH]" https://tljh.jupyter.org/en/latest/topic/whentouse.html

SLSA; Supply-chain Levels for Software Artifacts:

https://security.googleblog.com/2022/04/how-to-slsa-part-2-d...

https://slsa.dev/blog/2023/06/slsa-github-worfklows-containe...

How do ContainerSec, DevOpsSec, and UI/UX apply to getting a perhaps necessarily at least sometimes restricted set of containers provisions to support STEM lab module workflows for learning?

1. Instructor: Specify e.g. docker.io/busybox:latest, and docker.io/buildpack-deps:container_tag as the necessary containers for the course/module/day

2. Student: Login to that context (as allowed by domain policy if necessary), have the container images pulled according to idk like a syllabus.yml before the schema.org/CourseInstance :eventSchedule :Event begins or at the start of class per a distributed URL/QRcode.

3. Student: Review and manage which containers are running with something like the podman-desktop indication bar applet.

4. Student: git push a repo of notebooks to be graded with ottergrader, okpy, nbgrader (and get feedback on a Pull Request)

Gaps/Challenges/Opportunities:

Instructors don't have CI workflows implemented in curricula, but easily could create a git repo that works with repo2docker and/or devcontainers.json.

Education Organizations don't have control over which containers are running on students' managed workstations, do have such monitoring for which apps are so errantly provisioned; and so students don't have containers but do have apps.

Android Apps are installed as APKs, which are a ZIP file with a manifest. Binaries on Android devices will not run without SELinux labels. SELinux labels for executables on Android can only be granted by (root or) a the process that installs the APKs.

This means that other installers like pip and apt (in Termux or any app off the Android Google Play Store with the new SDK) cannot work in an Android App in a VM on a Chromebook. This means that e.g. Termux could work from the Play Store only if they repack every installable package as an APK on the Play Store. Python is installable with Termux on Android with Fdroid; but the Fdroid Android App repository ("Allow third party sources" (with a different cert trust root)) doesn't work on Chromebook Android, so FWICS you can't install Python with Termux apt on a managed Chromebook, and you can't keep sideloaded APKs from Fdroid updated with an unmanaged Chromebook: a [Google] dev would just use containers in a VM (or CI) instead.

JupyterLite and VScode.dev work in a browser tab because everything is compiled to WASM (WebAssembly), but the browser traps shortcuts like Ctrl-P.

So then you might say, "wrap JupyterLite in Electron or similar so it works offline as an app with all the keyboard shortcuts that you need". (Electron apps run a web app locally in a browser without the chrome (the address bar and back buttons); but if 5 apps each depend upon unique copies of Electron that they must repack and that users must keep updated, app sizes are suboptimal due to lack of a proper package dependency model for Android APKs.) Flatpack is neat, supports package dependency edges, and supports having multiple versions of a package installed, but most flatpaks have similar boundary violations where the guest container is insufficiently isolated from the host machine. VScode flatpak, for example, can call commands on the host with `flatpak-spawn` or `host-spawn` or the additional package for the vscode flatpak copy of the `podman-remote` go binary. distrobox and fedora/toolbox make it easy to mount your entire $HOME into the container with the correct UID and file permissions: `distrobox create arithmetic; distrobox enter arithmetic` provisions a container and opens an interactive shell within the container. ChromiumOS's zygote messages also cross container/vm boundaries IIRC.

gvisor is considered good enough to contain containerized workflows for shared multitenant workloads at Google; and so it should also probably be useful for getting devcontainers.json and at least vscode working on Chromebooks for the kids.

> ChromiumOS's [sommelier also crosses] container/vm boundaries IIRC.

chromiumos/docs/+/HEAD/containers_and_vms.md > Can I run Wayland programs? with Sommelier: https://chromium.googlesource.com/chromiumos/docs/+/HEAD/con...

But that doesn't solve because containers and vms aren't on and aren't supported for their accounts.

A school chromebook's access to containers could be controlled by setting the containers.conf repo URL to a Container Image Repository controlled by the school. GitHub, Gitea, and GitLab all support storing (OCI) container images.

An instructor would import a container image with an associated Pull Request that causes an Action to run to (1) scan the container and its SBOM Software Bill of Materials; before (2) hosting the container image for the students and (3) regularly (along with e.g. Dependabot, which for security regularly checks for references to outdated versions of software in GitHub repos) .

It looks like GitHub supports 3rd party code scanning tools, too; so Instructors and Students could auto-scan for security vulnerabilities and get reports back in the Pull Request https://docs.github.com/en/code-security/code-scanning/intro...

GitHub Project Templates are designed to be forked; e.g. like an assignment handout to be filled out (that already has an /.github/workflows/actions.yml and README.md headings). Cookiecutter is another way to create a project/assignment/handout/directory/git_repo skeleton; with jinja2 templates to generate file names like `/{{name}}/README.md` and file contents like {% if name %}<h1>Hello World, {{name}}{% endif %} . jinja2 is a useful skill also for ansible [collections of roles of] playbooks of tasks.

chromebook-ansible installs a number of apps by default (including docker and vscode (instead of podman and vscodium or similar)), but because there are variables in the playbook, you can change which parts of the playbook runs by specifying different parameters with ansible inventory: https://github.com/seangreathouse/chromebook-ansible#include... https://github.com/seangreathouse/chromebook-ansible/blob/c8...

It would be helpful to be able to provision [Android and Chromebook] devices with [Ansible] like it is possible with Mac, Windows, and Linux devices (without a domain controller; decentralizedly and for bootstrapping). It appears that there happens to be no way to `adb install play-store://url` with Ansible, but there is news about Ansible support for Enterprise Chromebooks.

There are [vscode] IDE mentions in the chromebook git repos IIRC. The [vscode] [docker/podman extension] could work with aforementioned functionality to limit which containers can be pulled or are running at a given time.

USE CASE (for a "STEM workstations for learning" spec): Create a minimal git repo project from a project template with cookiecutter-pypackage or similar.

A minimal project [template] would have at least:

  /README.md            # h1, badges, {{schema:description}}, #install, #usage, #license, #citation
  /LICENSE || /COPYING  # software/content license terms
  /devcontainers.json   # for vscode and other IDEs
  /environment.yml      # which packages to install (conda, pip, repo2podman)
          
  [/src]/example/__init__.py
  [/src]/example/main.py
  
  /tests/
  /tests/__init__.py
  /tests/test_main.py

  /example/tests/  # this dir would ship with the package, so that that tests Could run in production

  /example/data/  # will be installed in site-packages
  /data/          # will not be installed in site-packages without a special setup.py

  /docs/
  /docs/conf.py                                                    # sphinx
  /docs/index.rst      # .. include('../README.md') .. toctree::   # sphinx
  /docs/_toc.yml       # jupyter-book
  /docs/_quarto.yml    # quarto
  /docs/_metadata.yml  # quarto

  # When we need to vendor _other projects in
  # we then need src/ (and/or lib/) for _those (and maybe ours_ 2)

  [/src][/example]/tests/
  [/src][/example]/tests/__init__.py
  [/src][/example]/tests/test_main.py
  [/src][/libexample2]/COPYING

This is a very common workflow for STEM (PyData) software; how is it done with Win/Mac/Lin (and bash and git) and how do we do this with our Chromebook with no Terminal or Containers?

Which brand, though? I have a feeling it's one of those first-party Google Chromebooks...

My daily driver right now is a mid-tier Tiger Lake board. You can get the equivalent for sub-$300 on Amazon. The client doesn't need to do much in the modern developer flow, running a browser, an X server and an ssh client is 90% of anything that needs to happen, with the occasional Linux Wayland client from the VM thrown in (Thunderbird for personal mail, occasional use of Audacity, stuff like that).

In most cases HP

I have a couple of Samsungs and a Pixelbook. You can BYOD with Chromebooks, too, so you can pick smaller, lighter ones or ones with bigger screens than the standard offerings if you’re willing to pay for it.

You can request the computer you want. They will push you towards Chromebook but you can pick a normal Linux machine or a MacBook or even a Windows computer (don't do this).

Someone at Google needs to support the top 80% desktop market.

I used a Windows laptop for some time. It made browser testing in IE significantly simpler and otherwise worked fine for running Chrome + remote access to workstation. It was also the only model offered with a garaged stylus, which I used and tested quite a lot.

I used that laptop to skip over the lousy overheating butterfly MacBook generation. Now I have an M1 Pro MacBook like everyone else.

They also offer Windows on the cloud VMs.

Yup!

They do, but for the googlers I know it's just as a thin client for their remote desktop software (https://remotedesktop.google.com/).

So wait to be specific here -- is the setup that people develop on:

1. chrome-os device

2. install a debian VM

3. do all their development in a VM where they can easily install packages they need etc?

4. so they are doing dev in a VM on a core-i3 intel machine I guess?

Not exactly. There are some ways to install GNU/Linux distros on Chromebooks, the Eupnea project's Depthboot script[1], for example, lets users build/run a distro by extracting the rootfs from an ISO file, and apply Chromebook-specific patches, like using ChromeOS' kernel, using keyd to make patches to support the Chromebook keyboard's action keys, and much others.

(Disclaimer: I'm the current maintainer of the Eupnea project.)

[1]: https://github.com/eupnea-linux-backup/depthboot-builder

If the question is about Google, they use the Chromebooks to connect to cloud hosted dev environments. Often these days that's the internal cloud based IDE whose UI is VSCode based.

For many legacy command line tasks, you SSH to a cloud workstation. More than ever though, you can get away with a lot of programming tasks without ever touching a terminal.

For those who really want a traditional Linux Desktop environment, you use Chrome Remote Desktop to connect to the same cloud VM that you SSH to.

As I understand it, yes, albeit it's much easier at Google than some places. Google is pretty much a supercomputer with a company built around it; the Chromebook can serve as your terminal into that supercomputer, accessing your files, codebase, and other resources all remotely.

Couldn't agree more. I recently bought a cheap $200 Chromebook and I have to say that it outperforms my high end Windows + WSL2 machine from work for programming related tasks.

Linux just works without all the WSL issues, I can run Visual Studio Code, Docker and anything that I tried so far.

It's actually a delight to work on. I can only imagine how much better yet it will be with a top tier Chromebook

I find this very hard to believe. There is no "$200 Chromebook" that will ever out-perform a "high-end" machine no matter if it's running Windows + WSL2 or not. So what are the specs of this "high-end" machine?

they did say "for programming related tasks" which could just be running vim.

I agree though, this claim seems unlikely to me.

I meant to say that it "outperforms" less in terms of speed (although it's not bad relative to the price of the laptop) but more in terms of developer experience. Everything just works in Linux and it's fast compared to WSL which I get constant issues.

The issue I see with WSL all the time is long waits as things start up. I have no idea what it's doing, but it is painfully slow starting nearly anything up. It's like drive reads are one character at a time or something! Once it gets going, things are fine.

WSL still has a lot of problems. You can find lots of issues on github that are common problems but yet open for years without a solution. Examples:

* Slower IO -- not sure if this can ever be fixed, but quite a bummer * cpu utilization at 100% due to an issue with WSLg #6982 * no access to Internet when host is connected to VPN #5068 * very slow network in some situations #4901

These are not some edge cases -- they affect things that I use every day. Some of them have workarounds but overall this is still not very usable. I decided that it was easier to just get a separate machine and install Linux on it.

This sounds like it is more about GUI latency due to a more agile desktop environment.

Sort of like how a Pentium 3 feels snappy on Windows XP and yet, this 13th Gen Intel Core i5 on Windows 11 feels sluggish. There is WAY more processing power on my newer machine but it doesn't translate to a snappy interface.

Nope, WSL(2) is just slow in weird ways. Launching a GUI-less Python interpreter takes several seconds for me on a powerful workstation.

I have a small amd 7840 (win 4) coming. I originally think as my win max 2 work quite well … then max 2 all goes down hill. The Ubuntu lts no longer work. As I use it just for wsl2 development and use got to sync I erase it. But then never be able to install again. Only Ubuntu non lts installed.

For Gui. Too hard. Done it once when win 11 coming up.

It is now a dreadful wait for win4 to come. Wsl2 …

For those suggest dual boot I have a whole thinkpad X now only in windows and only if it’s do a bit action in the boot loader.

May be I should try Chromebook.

This is generally true if you include time spent rebooting and applying updates, and dismissing "knock, knock, it's Valentine's Day" notifications from windows, etc.

Depends on programming language. Not every compiler benefits linearly from 16 cores.

a $200 chromebook blows away a $1000 ipad for develompent. It's got nothing to do with raw horsepower but rather software support. for example chromeOS has developer tools. the ipad doesn't.

Yeah we’re going to need specs of both machines to begin to believe that lol

Do you have VSCode and Docker installed on the Chromebook?

I have been interested in buying a Chromebook for dev purposes.

Yep, just launch the built-in Linux VM (i.e. search "linux" in settings and click one or two buttons).

Then install VSCode and Docker as you would on any Linux system.

You can then launch them from the ChromeOS desktop environment as if they were native ChromeOS apps. It's really quite seamless, much more so than WSL (and better performance IME).

Don't. Install code-server on a remote server. Your chromeOS device is a just a front-end, you don't need to actually run anything on it besides a chrome browser pointed at your code-server instance and an ssh connection.

It’s fine if what you like about Linux is running Linux apps. But for me, it’s the privacy, the control, the choice of desktop environments etc. I can run VS Code on anything. And Firefox runs like garbage on a Chromebook, so, what’s really the benefit of using the only OS that won’t even run my preferred browser?

Paying top dollars/euros for a laptop with 8GB/128GB isn't my idea of an ideal developer laptop.

8GB/128GB goes a lot further on a Chromebook than it does on creaky, old, slow, bloated Windows. And Chromebook prices are very good.

I recently got a Chromebook and I'm amazed at how snappy and fast it is. And its built in Linux is amazing.

If you say so. I'm on windows and most of my memory is going to chrome and firefox.

I've had some pretty severe issues with a chromebook running out of memory because the devs decided swap wasn't allowed (and I could never get the kernel to build and install properly). The builtin chrome definitely doesn't stop single websites from using most of a gigabyte of RAM.

Nope, not good at all, and my Asus 1215B proves otherwise.

300 euro from 2009, upgraded with 8GB and 1TB SSD, and with native graphics that beat WebGL 2.0, running latest Xubuntu.

if one is already a geek it is not needed. The only reason myself being a geek moved to chromeos

- no need to worry if upgrading some Xorg will kill Xserver. Yes, it does happen if one has autoupdates

- Will my zoom/camera/mic work after I make pulseaudio->pipewire-><whatever latest>? No idea but chromeos - just works

- There are software engineers that have no installation/hardware/sysadmin experience (or they dont want to learn).

- Just close and open device. Chromeos is instant. (yes, one can fiddle with pm-utils to get modules (un)loaded - no life is too short to fix these.

- Many programs like netflix need some form of terrible DRM and dont work with linux. Some people still need to live with DRM.

I thought we were discussing about ChromeOS for developers after all.

> ChromeOS got good and is wildly underrated for software development.

There are laptops sold with Linux support in mind, those Asus netbooks were such laptops.

As for DRM, just install Chrome, the Web nowadays is ChromeOS anyway.

You don't pay top price for Chromebooks; you can get a good one for in between 200 and 300 USD

Not in Europe, so top euro if you prefer, and still with a junk hardware configuration.

Oh interesting; given USD and Euro relative parity nowadays, I assumed they would be 200-300 Euro as well

There is a new version you can get directly from Google that works on quite a few devices, especially high end ones.

I loved Chromebooks. However I've been pretty turned off by them when my Chromebook which was working perfectly fine recently told me it's not getting security updates anymore. Now because the OS and browser are the same machine, the whole system is insecure.

Next laptop will be a framework, so I guess I'll see how that goes.

They've extended updates recently https://support.google.com/chrome/a/answer/6220366

For old models as well

Not for the ones that ended support this August.

I have a kevin (Samsung Plus v1) and flashed it with libreboot for Linux at that point.

Similar to you, I'm a happy Chromebook customer with a good Chromebook that no longer receives updates since earlier this year. But Google also offers ChromeOS Flex [1] which I now run on my Chromebook.

You can even install ChromeOS Flex on a non-ChromeOS PC.

[1] https://chromeenterprise.google/intl/en_ca/os/chromeosflex/

I think they're decoupling the os and browser releases, although I'm not sure if it works for old ones or not. https://www.androidpolice.com/chromebook-decouple-chrome-fro...

ChromeOS is wildly underrated in general, not only for software development.

App sandboxing on standard (non-ChromeOS) Linux distributions is painful and finicky, while it "just works" on ChromeOS.

I wish there was a non-hacky way to use Chromebooks without a Google account.

The hacky options are:

- "Switch to dev mode". But I don't want to be prompted to factory reset each boot.

- "Create a dummy Google account and use that". But I don't want file syncing and tracking to reach Google at all, not even on a dummy account.

- "Create a dummy Google account and use guest mode". But I want persistent storage.

Chromium OS might be a good choice for you. I ran it on my Pinebook Pro for a bit and really liked it, and it's much more open.

Thanks - I had a very brief look at Chromium OS, but couldn't spot answers to:

(1) Is there a de-googled version of Chromium OS?

(2) Is there a non-hacky way to install it to a Chromebook?

I haven't used it yet, but maybe openfyde.io is one of the de-googled versions of Chromium OS

Nobody has the time to build, test, and maintain Chromium OS. Distros barely manage to build and maintain chromium.

> - "Switch to dev mode". But I don't want to be prompted to factory reset each boot.

Developer mode simply puts up a splash at boot warning you that the OS is custom, you just press enter to boot. The requirement to do a drive wipe is a one-time thing when you enable it the first time (for obvious reasons, to prevent exfiltration of data stored by a secured OS).

Thanks - has this changed in the past few years?

A few years back (when I last looked in depth), it was very easy at every boot (not only first boot) to accidentally wipe everything - e.g., https://www.reddit.com/r/Crouton/comments/3be2su/reducing_ri...

I also remember that it made a loud beep on every boot!

I used a Chromebook as my main laptop for a year in college, and I always had to apologize to nearby strangers for the beep.

(CS major, coding happened mostly over SSH to the school servers, but I did run RStudio locally)

How often does one reboot their laptop around nearby strangers? I gotta be honest that some of these criticisms seem a little strained. I mean, it's true, they beep at boot when dev mode is enabled!

It’s been awhile and I don’t remember why I had to reboot, but it did happen. I guess past me did a lot of work in cafes, office hours, and common areas.

I do remember that running a certain R program consistently caused the Chromebook to turn off, which was quite an issue for one particular office hours session!

I shut all of my computers all the way off when I’m finished using them, which means I have to turn them on when I start using them.

Is this an adaptation to some past trauma? I can't imagine a good reason to do this today, certainly not with ChromeOS.

I don't think it's trauma, although I've been burned with suspend/wake cycles before. Suspend works great. It is usually that wake part if it's going to go wrong.

If I close the lid, when I get back _I_ need a clean slate. I'll never remember what I was doing anyway.

Modern machines boot and launch apps so fast I'm not really saving any time sleeping an empty desktop either.

Interesting. It certainly costs several seconds to start and login to ChromeOS, while I have always enjoyed the fact that unlike other operating systems it is up and running before I even get the screen unfolded, from sleep.

> while I have always enjoyed the fact that unlike other operating systems it is up and running before I even get the screen unfolded, from sleep.

Other devices, maybe; it's at least as much firmware as OS. To this day the fastest wake from sleep I've seen was a random midrange Lenovo laptop that I got used, which is slightly maddening.

When talking about other OS, you might want to turn it off if you have your disk encrypted. So it serves its purpose.

Good point. I do indeed encrypt devices that leave the house.

I used a Samsung Chromebook sometime 5 years ago, and it couldn’t handle suspend/sleep well. I could leave it overnight with 80% and find it with 0% in the morning. So I learned to turn it off each time I stop using it. It booted within seconds anyways, so the only issue was to enter my gigantic generated password.

For me ChromeOS’s top UX fault is the password. You either do it with pin, or with a Bluetooth device to unlock. Otherwise it’s pain to enter the password.

Question out of curiosity: did you happen to have some sort of USB device plugged in when you put it into suspend?

Both pin and phone unlock are supported, as of today.

No USB device was ever plugged into the device.

There were days that you need to enter developer mode to turn on pin unlock, and Bluetooth devices came later on. I remember that pain of needing to enter my very long password in each boot. Horrible UX.

I interacted with a recent (a couple of months) Chrome OS Flex device (a regular old PC laptop of a senior that I know and helped to establish a basic computer for him), and it didn’t work on the first boot. It was a huge problem for him to enter the password, especially a strong one. I set up a pin with his birthday, which never worked. It worked only if you logged off the account (but didn’t turned off the computer). But if you start fresh, then you won’t be able to use the pin. I ended up setting his Google password to his birthday with dots and some letters, e.g. Qw25.12.1935, which Google allowed and which worked for him. He enters his password letter by letter and for him it’s a worse UX than before, when he had Windows XP that just boots and has Chrome (outdated with no option to upgrade) installed. But I convinced him this new way of things is better. At least it loads momentarily, which he likes.

And on top of that, built in Bluetooth adapter doesn’t work on that very laptop to connect his Android smartphone. The Bluetooth module works, but it doesn’t with the software for some reason. Brief googling showed me it’s easier to buy usb Bluetooth module and try with it. Which I did, but haven’t checked that yet, as he lives quite far away from me. As of now he uses the laptop somehow.

Isnt suspending an adaptation to trauma? The trauma of slow drives/startup or being interrupted constantly?

When I put my machine e away I am usually 'done', and when I open it, it isn't to see where I left off.

Being interrupted isn’t something that can be solved with technology, it’s more a lifestyle thing

(also sometimes you might just want to take a break or move somewhere different without starting from scratch)

The key combo you use to get into dev mode, ctrl+D, will exit the warning screen before it beeps.

How much of that has been upstreamed? I dug around a little but could only find things on upstreaming kernel patches.

What in particular needs to be upstreamed and to what projects?

Completely agree. Now if they would just add a meta key to the bottom row of the keyboard I'd be a happy user. Ctrl and Alt are not enough. And seriously, they are comically large on every chromebook I've owned. Give me a meta key in all that wasted space.

There's the button that replaced caps lock. I mean, yes, I'd still rather have another button, but it does work in my personal experience.

Oh true, I'd forgotten that. Of course the issue with it being in a different place is that many people use multiple OSs and muscle memory is a thing. I'd rather have a reprogrammable key where meta should be.

ChromeOS might be great, but I wish I could just buy it from an OS company, not a company that wants my data.

How does it go with things like tracking or serving personalised ads?

Genuine concern with anything google. Current and future risks.

I used a Chromebook for a few months including for software development, but find there are a number of major issues (as of 2021):

* window management was a hit and miss. I was not able to do split screen for a Chrome window and a Linux window (vscode). You can do that for two Chrome windows. A big disappointment * many GUI applications are only available through... Android Play Store, e.g. Cisco Anyconnect. Fortunately this works, but it's not an enjoyable experience. * Chromebook built-in keyboards usually don't have F11 or F12 keys, but you need them as a software developer.

And there are a number of other smaller issues that made me feel it would be easier to stick with a "standard" laptop, although I do think there is a lot of potential. I sold that Chromebook later.

So many people over the years tried to turn their ipad into a remote development machine and failed spectacularly, because of the aggressive app suspend (your ssh/web sessions get disconnceted) and the weird keyboard support in iOS (keyboard shortcuts for text navigation are not the same as PC). In the mean time, ChromeOS is the perfect OS for that. I have my own bare metal server with code-server installed. My chromeos 2-in-1 detachable is absolutely perfect for that usecase, and I can connect my split mech keyboard. Best of all ? I bought that ChromeOS tablet for $180 USD on amazon. It works BETTER for remote development than a $1000 USD ipad.

Yeah, it is funny how successful Linux became as a desktop while basically noone was paying attention.

I just wish the keyboards were more developer friendly. Give me F keys!

Yeah, I put Linux on my Chromebook, but I've yet to figure out how to use the F keys, in ChromeOS fn does it.

You can do Search/Launcher + [action key here], for example Search/Launcher + ← triggers F1. There is also a setting on ChromeOS that makes the action keys into function keys.

My F keys go to 24, and I've got 7 macro keys in addition to that. It was just about enough for everything at any given time. Normal keyboards feel limited now.

Actually the best thing was having keys nobody else has so their function was up to me to decide at absolutely all times.

I haven't used F keys in years.

I used them heavily. Multiple times an hour. I’d be utterly lost without them. It would be like taking the shift key away.

Leaving a lot of productivity on the table. Those and rest of the hotkeys allow me to duck out early at work. ;-)

Haha no. My shortcuts are just not the F keys, so I don't have to hunt-and-peck. No mouse either.

On the other hand, if the F-keys are too far away, you may be over-optimizing to the other extreme. Or have one of those abbreviated keyboards. Well into niche territory. :-D

The only reason I don't use them heavily is because there's no way to know if they're F keys or media keys at any given moment in any random keyboard.

Search + top row registers as the first few f keys. Cumbersome but workable.

I just wish the trackpad had more than one button. My C434 has the Apple Hockey-puck mouse of trackpads.

settings => device => keyboard => treat top-row keys as function keys

Buy laptop without ChromeOS.

Install ChromeOS Flex.

Be happy.

I did this with a Lenovo X1 Nano, my favorite chromebook ever.

Isn’t Chrome OS Flex discontinued ?

Not that I know of!

Flex is significantly less secure than ChromeOS on Google-approved hardware, and that fact is the first thing Google tells you on the page describing Flex.

It became successful because the Linux-y stuff are invisible to the average non tech users, just like on Android.

What is "Linux-y stuff"? Is Linux defined by having to use a terminal?

Android is basically an entirely different OS stack running on top of a Linux kernel. ChromeOS used to have it's own rendering and window management pipeline among other things, but as time has progressed their stack has gotten progressively more FOSS. You can run Linux apps, open a terminal, play Steam games via Proton, all from the default window manager/UI.

It's rootfs is locked down by default, but so is Fedora Silverblue or SteamOS. It can be optionally locked down further and turned into a managed system, but so can any distro. In terms of UX it's much more Ubuntu than it is Android.

I would include footguns, conf/dotfiles, hardware incompatibilities and workarounds (why does mpv need 1000 flags? ffmpeg? this is hardly even exaggeration!), multiple ways to reach the same goal (e.g. install software), often missing some peripheral support, CUPS, systemd, package conflicts, poor availability of most paid software, need for more technical knowledge (e.g. the standard Linux directory tree, how to install dependencies, run levels), usually less power efficient OS than MS/Apple, and so on.

When I ran ChromeOS (years ago) I recall having only a few intuitively named folders with most everything in "Downloads". I never needed to build my own stylus Wacom definition or switch operating systems to get the entire audio system functional. (In fact, the Gallium team had a lot of trouble getting the ChromeOS audio to "just work" on some platforms, such as Sentry.). Everything that came with the laptop worked. You could always pop up the shortcut overlay to remember how keys were mapped, Chrome browser didn't need weird codec or GPU flags or dependencies, I didn't need any obscure addition to the bootloader, the thing would run for over ten hours on a charge, I had no issues connecting to my school's networked printers.

Sure, ChromeOS still has dotfiles for things like editors, but it's not nearly as newbie-hostile as xorg.conf, /etc/profile, fstab, /etc/modprobe.d/blacklist.conf, GRUB, and all of the other service/module/daemon configurations needed to get something like Arch running on a random old 486 PC or laptop.

Then, the ChromeOS community started to make code editors and compilers accessible without needing crouton and needing to remove a screw from the motherboard.

Around this time, I started using a Dell XPS and stopped using the Chromebook. It developed some sort of memory problem sitting on a shelf. It still starts up but will crash anywhere between a few seconds and ten minutes, otherwise I'd repurpose it as a MIDI player/recorder for my digital piano.

From my recollection of ChromeOS, it seemed more stable and performant a decade ago than Windows 11 today.

Linux? I had rough times with Ubuntu around 10.04, it was much improved by the time I had it on the XPS in 2017, and now when I run Ubuntu on a ThinkPad Z13 or NUC Enthusiast 11, it has far more software and hardware issues than 16.04 and 18.04 on the XPS.

Making Linux stuff invisible isn't what fixes it and prepares it for end consumer usage, though. If you get rid of the Linux terminal, and still have many under-the-hood and polish issues that the user could only fix if they had a terminal, you have a bad product.

> I just wish the keyboards were more developer friendly. Give me F keys!

At the same time, I applaud them finally getting rid of Caps Lock and replacing it with a general utility feature (search)

I've been saying it for years and people just told me to shut up and told more sarcastic YOTLD jokes.

The linux desktop crushing Windows is inevitable. It's just not going to play out how people thought it would.

ChromeOS is my x-window. Debian is my terminal. Google has done a nice job of integrating the two. The only real constraint is the hardware.

Disclaimer: I was a pre-release beta tester for ChromeOS.

The matte-black laptop they shipped out to beta testers for ChromeOS is still the best laptop I've ever owned. Maybe not processing speed-wise, but the size and everything else was perfection.

Ah yes, the CR-48 [1]. Named after an unstable isotope of the element chromium...

[1] https://en.wikipedia.org/wiki/Chromebook#Cr-48

I still have mine, but the hinge broke in a very annoying way that probably needs a full replacement.

Can I install Firefox without jumping through a bunch of hoops and without it feeling like a second class experience?

Yes.

I use Firefox on my work Chromebook so I can access my personal Gmail while logged in as my work account.

It integrates perfectly and is installed as easily as e.g. vscode is. The do not put up any barriers just because it is Firefox.

How do you install it? Do the fonts look good?

https://support.mozilla.org/en-US/kb/run-firefox-chromeos

Indistinguishable from any other native app - fonts are fine.

Thanks! Sounds like it's improved a lot since I tried it years ago.

You could say that ChromeOS is Google's desktop environment with a Linux kernel, also. Which actually is!

This might be a bit more accurate, especially if they ever switch to Fuchsia under the hood.

At this point I'm convinced that if Google ever succeeds in making Fuchsia a "success", they would drop it all together within a year.

Google should invest in ChromeOS as a serious PC/Laptop OS. It is ridiculous that Google made the choice to make ChromeOS the "cheap" OS.

This seems to be the direction they're heading with the recent Chromebook Plus announcement: https://blog.google/products/chromebooks/chromebook-plus/

> It is ridiculous that Google made the choice to make ChromeOS the "cheap" OS.

The original goal was to make a laptop performant enough for a wide swath of common web based tasks that was very affordable to purchase and administer. It succeeded at that very well, especially in primary/secondary education.

For many years now there have also been high performance Chromebooks available that can run a full Linux environment, drive multiple monitors at high resolution, and run heavy software like Figma.

The engineering investment has been there, but the storytelling about the capabilities of these devices hasn't taken place. Now that's starting to happen, and probably non-coincidentally when Adobe Photoshop for the web is available.

Except that most people view Linux as open source etc.

Chromebooks aren’t Linux in the sense people who want a Linux computer care about

https://chromium.googlesource.com/chromiumos/

That'd be more interesting a reference if it were actually possible to run without making your own conformamt special hardware.

Google built their own embedded controllers to power this platform, unlike anything else that came before. The source may be open, but no other machine anywhere will run this.

It has taken heroic efforts to port ChromoumOS to conventional x86 hardware platforms. Google then bought the people who spent years porting their proprietary impossible to run system on normal laptops. I don't know enought to say how actively Neverware's efforts have been continued, but so far it still seems like running Chromium OS elsewhere requires epic feats, that integration has not proceeded any further than before the acquisition. https://www.theverge.com/2020/12/16/22179242/google-neverwar...

It's to my understanding that the Neverware acquisition eventually led to ChromeOS Flex which is ChromeOS designed to run on any generic x86_64 platform.

https://chromeenterprise.google/intl/en_ca/os/chromeosflex/

https://support.google.com/chromeosflex/answer/11552529

Most of it is open source similarly to the Chrome/Chromium situation. But you're right that many Linux desktop users won't care about it due to it being locked down and limited, which was demonstrated in the article. It's not something I'd use on my personal devices.

That looks nice. I like the Material You look and feel and UX. I want to try it.

Can I install Chrome OS as simply as I installed Ubuntu? With a USB drive and a friendly install process (on a separated partition on my SSD, my main OS is Windows 11 now).

Yes. The chromeOS Flex installer image can be written to a USB drive and then booted from your usual computer.

https://support.google.com/chromeosflex/answer/11552529

You can unzip this archive and write the unpacked BIN to a USB flash drive using `dd` like you would for Ubuntu. You can also just follow the Google instructions.

https://dl.google.com/chromeos-flex/images/latest.bin.zip

Great! Will try that since I see is an official documentation.

I assume yes, but do you know if it is mandatory to have to login to the OS with a Google account? Or can be used with a local/offline account? I prefer the later.

Yes, it's necessary to have a Google account for the typical case.

You can login as a guest, but the data created in that session isn't saved – it's "ephemeral."

An yet, google still wont release a official vmware/virtualbox image for chrome os or generic ISO. If they dont believe enough to let users play and enjoy it, why would I buy a laptop just to play with it.

I love how it has linux containers and linux available, why google has its artificial hands off policy, making you jump hoops of downloading a 3rd party install, convert it into a VM, and then dont do an OS upgrade or it breaks the vm, its just a bad experience.

I just recently switched from Ubunto to ChromeOS Flex and my quality of life has gone way up. I had so many frustrations with Ubuntu when switching displays, unlocking, sharing screens... all gone with ChromeOS flex and I get to keep my linuxdev tools. So happy!!

What happened to the Fuchsia project?

It's still going and Google still refuses to explain why it exists. It was rumored that some of the team was laid off during recent cost cutting.

It’s not rumored. It was widely reported on and many people discussed their impact publicly.

Fuchsia is shipping on real devices today (their home hubs) although yea it’s not clear why, they now have quite a few operating systems they manage.

1. Android of course. Chrome casts and phones and tablets use this.

2. Fuchsia for the home hubs.

3. ChromeOS for the chromebooks and stuff.

4. GCP probably has a cloud Linux like AWS but tbh I’m not familiar.

They’ve killed “castOS” which was a very limited Linux based system I think.

So more like

1. Linux - with some variations of user land based on use case. Primarily ChromeOS and Android.

2. Fuchsia - with unknown motivations and use cases

castOS was a stripped-down Android.

Rumor has it, it may eventually replace Linux as the underlying OS to Android/ART. By now I'm thinking G's leadership is realizing the epic undertaking it would mean to bring Fuchsia to maturity... and I give Fuchsia a 50/50 chance of ending up in the vast Google graveyard (https://killedbygoogle.com/) in the next 5 years.

I'm curious why they couldn't poach one of the L4 microkernels to build Fuchsia on, specifically SEL4 which is used in Genode/SculptOS, same as they did with Linux and Android. It would've given them a strong base to build on, saved time/$$$....

They tried that too... https://opensource.googleblog.com/2022/10/announcing-kataos-...

I wonder why MS don't compile VS Code directly for ChromeOS?

You've been able to use vscode on ChromeOS for several years: https://code.visualstudio.com/blogs/2020/12/03/chromebook-ge...

I've used it a lot - works great.

Yeah, I always felt it was a kludge though to have to run it through Crostini rather than native. Felt like laziness on MS part when they easily have the resources to make it a native app.

Glad to hear it works well, though!

I stopped reading when I saw "what is a desktop environment?" ...

A miserable little pile of applications. But enough talk, have at you!

It all started with the BigBang... more words, better seo.

The team has both made a ton of effort switching off their proprietary Skia based rendering tech and adopting standard Wayland, and has put forward huge effort to making running incredibly well integrated real Linux containers just work.

The headline is true. ChromeOS is Linux with Google’s desktop environment. But it obfuscates the details. It's a damned by omission statement. It has some really good sauce to help you not notice often, but it's not at all a Linux desktop environment one can regularly use. You can do a lot of Linux desktop-y things but only through well crafted special unique wrapped processes that mostly but not fully help mock & emulate a regular Linux desktop. Even though it now runs Wayland, the apps you want to run will have atypical intermediates up the wazoo.

And no one else uses any of this tech. ChromiumOs has so much interesting container tech, does such an interesting job making containers think they have a regular Linux / FreeDesktop environment. It's far far far far deeper virtualization than for example https://github.com/containers/toolbox . But you know what? Google has made zero effort to get these pieces adopted elsewhere. It's open source but not intended for use outside Chromium/ChromeOS. I respect & think ChromeOS is a quite viable Linux, and it's so much closer to the metal & more interesting, amazing tech, but my gods Microsoft has gone 300x further to establish wsl2 as a sustainable community effort folks could use & target, in a way that ChromiumOS has done nothing about.

It's sad how Google has transformed from a company that appreciated & worked with ecosystems, that drove things collectively forward, into an individual player that does their own things & delivers from on high. ChromiumOS is such an incredible effort, but it's so internernally drive & focused, and it's hard to believe in such a wildcat effort, even though it's so so good. It keeps coming into better alignment with Linux Desktop actual, but via shims and emulations that no one else cares about or which seems marketed elsewhere. And that inward focus makes the whole effort both so exceptional & promising, but suspect. Such a different nearby but alternative & separately governed universe. ChromiumOS/ChromeOS do excellent at faking being a Linux desktop, and wonderfully have increasingly drawn more strength from that universe, but are still wholly their own very distinct very separate very controller other space. In many ways that's great, secure, good, and miraculously transparently done. But it's still hard to really trust, being such a weird alien impostor, faking so much for end user apps, and there's tension in believing ChromeOS will keep straddling the rift in pro-user manifestations forever.

Echoing: doing some "deep" troubleshooting of an issue on my Chromebook (since like 2006 + crouton/crostini), I read about their newer security/architecture for Linux apps running in chrome.

https://chromeos.dev/en/linux/linux-on-chromeos-faq#why-run-...

...see also the linked: "security" and then "glossary" to get a feel for the component complexity.

It is pretty astounding, and astoundingly complicated, but mostly transparent as to how the host + guest integrate.

Yeah, you can run "Inkscape" and the GUI just "shows right up" on the chromebook... but there's like 18 layers of security mitigations and complexity with virtualized device drivers and audited communication channels that are all (nearly) completely invisible to make it look like "it's just running /usr/bin/inkscape on the same machine, what's so hard about that?"

... and tracking

No. Chrome OS is an OS using the Linux kernel and a custom userland.

Android is also not "Linux".

would it be correct, to say, it is a linux, but not gnu linux ?

No, it literally is GNU/Linux, with glibc and coreutils and everything.

EDIT: Rereading the thread I should spell out: I only meant ChromeOS; Android is indeed different.

Incorrect. If it runs the Linux kernel, it is Linux. Period. End of story. Android is Linux.

What do you think is incorrect, exactly? ChromeOS is a GNU/Linux distribution - a Linux kernel with GNU and other userspace components on top - derived from Gentoo.

Android, it's true, is a non-GNU Linux distro, which does use mostly custom userspace parts over the Linux kernel.

I wasn't intending to discuss Android, just to point out that ChromeOS is a GNU/Linux system, and a surprisingly vanilla one at that.

>ChromeOS is a GNU/Linux system

Personally, it doesn't qualify as GNU to me as the only GNU software included AFAIK is Bash. To me GNU requires coreutils to be there and usable.

Yeah, ChromeOS uses GNU coreutils and glibc; it's a Gentoo derivative, not some alien like Android. I don't know how you define "usable", but if you switch to developer mode to let you get a shell at all then it feels about like any other GNU/Linux distro.

Normal builds of ChromeOS do not include coreutils.

https://chromium.googlesource.com/chromiumos/overlays/chromi...

>it's a Gentoo derivative, not some alien like Android

Android is no more of an alien than Gentoo.

>I don't know how you define "usable"

It means when the user logs in they are given a bash shell so that they can use GNU coreutils. This is similar to UNIX in which you log in and are then able to use UNIX's built in utilities.

>but if you switch to developer mode

Developer mode is a Debian container.

> https://chromium.googlesource.com/chromiumos/overlays/chromi...

That file specifically lists bash, and strongly implies coreutils in general with things like

    # CROS_* : Dependencies for "regular" CrOS devices (coreutils, etc.)

although the actual inclusion appears to be at another layer.

> It means when the user logs in they are given a bash shell so that they can use GNU coreutils.

Okay, then by that exact definition I'd agree that ChromeOS isn't a usable GNU system until you enable developer mode.

> Developer mode is a Debian container.

No, developer mode is a mode that gives the user full control over the machine: https://chromium.googlesource.com/chromiumos/docs/+/HEAD/dev...

Once you've enabled that, you can actually just switch VTs, get a getty prompt, and log in to bash.

>although the actual inclusion appears to be at another layer.

coreutils is included in dev builds of the os, /virtual/target-chromium-os-dev. That comment is also in this file too.

>No, developer mode is a mode that gives the user full control over the machine:

Cool didn't know that

You're correct, but the person you replied to is correct as well. ChromeOS is GNU/Linux. Android is Linux but not GNU/Linux

The Android libc is called bionic.

No, it wouldn't! Linux is the kernel only. A small part, and very important, of the ChromeOS ecosystem.

You could say this about almost any Linux-based GUI-first system.

Linux is a small part, and very important, of the Ubuntu ecosystem.

The GUIs running on top of a Linux kernel are written in C, C++, or another programming language. That's not Linux.

> That's not Linux

I don't think I said that it was :)

Linux is the name of the kernel

If it runs Linux, it's Linux.

If it runs the Linux kernel, it's Linux. It isn't Windows, Mac, BSD, SunOS, or any other OS...it's Linux.

Chrome/Linux instead of GNU/Linux?

Remember, GNU is a collection of packages. ChromeOS still has GNU utilities built in, therefore, it is still running on GNU/Linux. Now, if Google made a GNU replacement, then the ChromiumOS kernel would have been named Chromium/Linux, or Chrome/Linux.

Reply on news.ycombinator.com