# Glacies x86_64 LiveCD Released (2021/02/16)

Finally the Glacies LiveCD is available. Currently only for x86_64 archictecture, although should be quite easy to extend it later.



From now the focus is going to be on ports, with the following goals:

Linux® is the registered trademark of Linus Torvalds in the U.S. and other countries.

# Raw Glacies QEMU Disk released (2021/01/26)

This image contains a “clean” (except it includes a compiler) Glacies installation (Arch: x86_64). It has the sole purpose of speeding up some things on the development side (although it can also serve to take a look at how things works).

# Glacies - A different Linux distribution (2021/01/13)

Glacies is an operating system, composed of the Linux® kernel and the Eltanin userspace. As part of the Eltanin project, it follows the same principles.

This distribution is considerably different from your usual one, it has its own non-standard libc (tertium), which was used to write the core utilities (ecore), the package manager (ports and venus) and a posix layer (simia) intended to replace musl in the future.

All the packages are statically linked, except for packages that wouldn’t work or would be too painful to make work.

The third-party tools which compose the system are chosen, when possible, based on the same principles which guide the rest of the project, for instance, netbsd curses replaces ncurses, libressl replaces openssl (bearssl may be considered later), quasar m4 replaces gnu m4, etc. (see posix-repo for details).

The init system is composed of sinit (from suckless) and perp (although i am considering replacing both with s6).

Currently the only way to build Glacies is manually, but in a few days you can expect a live-cd with a more friendly way (scripts).


Venus is a lightweight and simple binary package manager for unix-systems. It uses the filesystem and flat files as database and entries, respectively.


Ports is a source-based package manager, able to interoperate with venus (although able to work alone or with another package manager). The repositories are tree-structured file systems, organized by categories, the packages are directories with a script describing how to compile them.

Old video, but still should give an idea of what to expect:


Tertium is possibly the most valuable piece of software from this project, it’s a replacement for the standard libc, with a different approach, giving special care to security, simplicity and elegancy.

A few comparisons:

/* mem routines comparison */
/* libc */
memcpy(buf, buf + 10, sizeof(buf) - 10); /* may pass unnoticed (should be memmove) */
memset(buf, 0, sizeof(buf)); /* insecure for cleaning sensitive data */
memcmp(buf, password, sizeof(password)); /* insecure for sensitive data */

/* tertium */
c_mem_cpy(buf, size(buf) - 10, buf + 10) /* works with memory overlap */
c_mem_set(buf, sizeof(buf), 0); /* secure */
c_mem_equal(password, sizeof(password), buf); /* secure */

/* malloc routines comparison */
/* libc */
malloc(x * sizeof(*ptr)); /* may overflow silently */
free(ptr), free(ptr); /* UB (double free);  */
realloc((void *)-1, 200); /* UB (non owned region) */

/* tertium */
c_std_malloc(x, sizeof(*ptr)) /* catches overflow */
c_std_free(ptr); c_std_free(ptr); /* ignores the second free silently */
c_std_realloc((void *)-1, 200, sizeof(uchar)); /* fails and sets errno */

Even being, somewhat, a recent library there’s already are a lot of work done: abstract data types, dynamic and static arrays, calendar, constant database, iterative directory recursion, formatted error messages, external binary execution, user-defined formatting, pattern matching, checksum and cryptographic hashes, buffered i/o, memory operations, random data/number/strings generator, c-string operations, tai time, portable unsigned integer store, utf-8, and a few more things.

Most of the routines, where it makes sense, consider their interoperability, as consequence, most of them are easy to extend or interact with other routines.

/* adding a new format to fmt (similar to Plan 9) */
struct user {
    char *name;
    char *gender;
    int age;

print_user(ctype_fmt *f)
    struct user *u = va_arg(p->args, struct user *);
    return c_fmt_print(f, "%s (%s) %d", u->name, u->gender, u->age);

main(int argc, char **argv)
    struct user u0 = { "Adam", "Male", 66 };
    c_fmt_install('U', &print_user);
    c_ioq_fmt(ioq1, "u0: %U\n", &u0);
    return 0;

It’s possible to add new hashes, formatting abilities to any routine that deal with strings, easily replace the internal malloc (although it must, like the original, detect double-free and non-owned regions), use strings (errstr) and numbers (errno) to handle errors, and other nice things.

About the future

I have good expectations for the future of this project in general, also there’s a lot of work done that hasn’t been put in public yet; I am working to provide a high-quality GUI environment by using arcan as a display server; also I am working on a new concatenative programming language (can talk more about it later).

This project surely has a lot of rough edges, but nothing that effort and time can’t fix; but for that I need your help, if you see the value of this project and want to see it continue, please consider helping:

Follow the public todo at: https://todo.sr.ht/~eadwardus

Linux® is the registered trademark of Linus Torvalds in the U.S. and other countries.