This is Snowflake, a highly experimental Linux distribution based on the musl C
library, with a per-process view of the /usr filesystem, such that users may
choose to have different perceptions of which packages are available on the
system. Snowflake runs on i[3456]86, x86_64 and ARM.

Within Snowflake, users may choose to change their view of which packages and
versions are installed. For instance, if you do not expose gcc in the default
set of packages, a user may compile packages like so:

$ gcc
sh: gcc: not found
$ with gcc
$ which gcc
$ gcc test.c
$ ./a.out
Hello, world!

To build snowflake, make a (or use the existing one), and run (in core/). Building a Snowflake root filesystem does not require
root. It runs the following sub-scripts, in this order:

* ./ Builds a cross-compiler targeting linux-musl. Due to a
  confluence of bugs, including possibly a bug in my GCC patch (which I'm
  investigating) as well as a pseudo-bug in GCC (GCC 4.7.0 can only be
  cross-built with GCC >=4.7.0), you currently need a cross-compiler for
  linux-musl. It's generally a good idea since it avoids pollution anyway. If
  at some point I figure out how to get GCC 4.7.0 to reliably compile with the
  musl-gcc wrapper instead of a cross-compiler, this step will not be strictly
  necessary, but will still be recommended. As a point of comparison, note that
  most other musl distributions require that you compile GCC 3.6 for musl
  before compiling GCC 4, so the number of GCC compiles is the same.

* ./ Builds prerequisites to build GCC for the guest. This
  needs to be done after buildcc and before buildroot.

* ./ Builds a Snowflake root filesystem. This is the only
  necessary step if building Snowflake on a native musl system.

It is mandatory to build out-of-source. To do so, put in a directory
of your choosing, then simply run the scripts out of the core/ directory.

Once you have the root filesystem set up, write it to an HD image:

* ./ Builds a Snowflake HD image from a root filesystem. This
  requires root, but for very silly reasons (it needs fdisk and loop mounting).
  If you don't have root, you can work around that requirement with, e.g., . In that case, run it as `umlbox -fw /
  -s ./`.

You may also chroot directly into the root filesystem, if your host kernel has
aufs. The first time you do so, you will have to run the init script, which
does in-tree configuration:

$ chroot root /usr/bin/init

That step is done automatically if you run Snowflake in a VM or a real machine,
it is only necessary if you use chroot.

Once you're in the Snowflake filesystem, the final step is to bootstrap the
last few packages.

$ /src/

Snowflake supports the NetBSD pkgsrc as a source of packages. The integration
is imperfect but working. To include pkgsrc, set WITH_PKGSRC=yes in your To use it, just `with pkgsrc` then build in /var/pkgsrc.
Installation will automatically go into separated packages in /pkg.

The default root password is "snowflake".

Snowflake can run on ARM, MIPS and PowerPC, though these ports are considerably
less tested. Currently pkgsrc does not work on musl+MIPS, but other
combinations seems to work. A native compile on one of these systems should
work just like a native compile on any other system. To cross-compile Snowflake
for them:

* Your must specify one of

* On MIPS, must additionally specify

* On PowerPC, must additionally specify
  GCC_BOOTSTRAP_CONFFLAGS="--with-long-double-64 --enable-secureplt"
  GCC_CONFFLAGS="--with-long-double-64 --enable-secureplt"

* Up to buildroot is as normal. After buildroot asks you to sudo, it will have
  some errors. These are normal.

* Use to create an image, even though it hasn't been finalized
  or bootstrapped.

* The image should be usable in qemu. Example commands are provided in

* Run /src/ to finish bootstrapping.