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 i86, 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:
sh: gcc: not found
$ with gcc
$ which gcc
$ gcc test.c
To build snowflake, make a config.sh (or use the existing one), and run
build.sh (in core/). Building a Snowflake root filesystem does not require
root. It runs the following sub-scripts, in this order:
* ./buildcc.sh: 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.
* ./build-gcc-deps.sh: Builds prerequisites to build GCC for the guest. This
needs to be done after buildcc and before buildroot.
* ./buildroot.sh: 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 config.sh 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:
* ./mk-hd-image.sh: 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.,
https://bitbucket.org/GregorR/umlbox . In that case, run it as `umlbox -fw /
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.
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
config.sh. 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
* Your config.sh must specify one of
* On MIPS, config.sh must additionally specify
* On PowerPC, config.sh must additionally specify
* Up to buildroot is as normal. After buildroot asks you to sudo, it will have
some errors. These are normal.
* Use mk-hd-image.sh to create an image, even though it hasn't been finalized
* The image should be usable in qemu. Example commands are provided in
* Run /src/bootstrap.sh to finish bootstrapping.