Sergey Bugaev committed public headers for the GNU Mach AArch64 port. He writes that

...there is now a real port of GNU Mach to AArch64, using these headers as its actual API/ABI. We got the Mach port to run glibc, several Hurd servers, and simple Unix programs, including things like fork/exec and signal delivery & handling working, which exercises these architecture-specific definitions (thread state & exceptions). We have also managed to do some testing on real hardware; although not everything is working yet, we have seen thread state manipulation & Mach handling an unaligned SP fault work as expected.

His email also mentions that the GCC patches that enable GCC to compile GNU/Hurd programs on AArch64 have been merged! This apparently will make it easier to merge his AArch64 specific glibc patches.

He also added new tests to check that threads handle signals well, and he also fixed a use-after-free in vmmappageable_scan(). He also hosted a lengthy Hurd code jam (apologies for the poor audio quality).

He also very notably added support to copy a send once right to Mach and MIG.

Some time ago, Sergey also wrote the terrible-mdns-responder, and if you would like to be able to type in ssh HOSTNAME.local and connect to a locally running Hurd, then you may want to try it!

Flávio Cruz fixed some issues with the Hurd compiling on GCC 14.

Luca Dariz fixed message sizes, where the size was not set by userspace, and he added another test to check message sizes on various code paths.

Debian GNU/Hurd now offers an experimental SMP GNU Mach kernel (32-bit only) and the official rustc compiler! Now that we have ported rustc to Debian GNU/Hurd, we can compile important packages like librsvg. Debian GNU/Hurd now can compile 71% of the packages from the Debian archive.

Now for something trivial but fun! I updated the guide on the Hurd wiki that shows how one can run their own personal ext2fs translator.

You could go crazy even! Why not make something like this:

 ~/silly <--> silly.fs
    |   \
    |    \
    |     \
    |      \
    |       \
   \|/       \/
  silly1 <-> silly1.fs
        ...

 /hurd/joshua/silly/silly1/silly2/silly3/silly4

Each sillyN is another ext2fs filesystem! Make sure that as N gets bigger sillyN.fs gets smaller. Let us know in the #hurd irc channel how "silly" you are.

The current record is ~/silly1/silly2 where each sillyN is a different ext2fs. Does anyone want to volunteer to beat the current record?

So if you want to test if your favorite packages work on the Hurd and contribute towards making the full GNU system usable for a wider range of people, please check the contributing page.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

Etienne Brateau modified console-client to use xkbcommon instead of x11 for xkb extended support, which improves keyboard layout coverage a lot!

Flavio Cruz also worked on porting GDB to the 64-bit Hurd, implemented setcontext/getcontext/makecontext/swapcontex () in glibc, and implemented child process resource accounting. The latter implementsgetrusage(RUSAGE_CHILDREN, ) and populates child related data in times().

He fixed the perl testsuite for the Hurd, and he also posted a RFC to enhance tracing utilities, which he used to port the RPC format to 64 bit.

Flavio also had a smattering of fixes here, here, here, here, and here.

Damien Zammit had some fixes including fixing the console with APIC enabled, patching GNU Mach to support ACPI v2, fixing baud rate on com ports, porting the Hurd to some AMD CPUs (WIP), adding HPET (high precision timers). He also worked on making ext2fs use xattr by default to store translators.

Damien also worked on more SMP fixes here, here, here, here, here, and here. Hurd currently boots in SMP mode on the BSP. Damien wrote a test program that lets you run a task on the APs.

Sergey Bugaev patched binutils to support the GNU/Hurd on AArch64, and he wrote some patches to make the Hurd easier to port here, here, and here,

Sergey also posted a fairly large RFC patch series for his AArch64 port. He writes:

MIG seems to just work (thanks to all of Flávio's work!). I'm using
 the same message ABI as on x86_64, and haven't seen any issues so far
 — neither compiler errors / failed static assertions (about struct
 sizes and such), nor hardware errors from misaligned accesses.

He also mentions that "the hardware hardening features (BTI, MTE, PAC) are currently 'not really supported', but I do want to support them in the future." Samuel merged many of the patches.

In Sergey's later glibc patch series, he wrote about the AArch64 port progress. He wrote:

Last time, there was no AArch64 port of GNU Mach, and so the only testing
 I have done was running a simple statically-linked executable on Linux under
 GDB, which, nevertheless, helped me identify and fix a number of issues.

 Since then, however, I have been (some may say, relentlessly) working on
 filling in the missing piece, namely porting GNU Mach (with important help &
 contributions by Luca D.). I am happy to report that we now have an
 experimental port of GNU Mach that builds and works on AArch64! While that may
 sound impressive, note that various things about it are in an extremely basic,
 proof-of-concept state rather than being seriously production-ready; and also
 that Mach is a small kernel (indeed, a microkernel), and it was designed from
 the start (back in the 80s) to be portable, so most of the "buisness logic"
 functionality (virtual memory, IPC, tasks/threads/scheduler) is explicitly
 arch-independent.

 Despite the scary "WIP proof-of-concept" status, there is enough
 functionality in Mach to run userland code, handle exceptions and
 syscalls, interact with the MMU to implement all the expected virtual
 memory semantics, schedule/switch tasks and threads, and so on.
 Moreover, all of GNU Mach's userspace self-tests pass!

 This meant there was enough things in place for me to try running
 glibc on it, and the amazing thing is my simple test executable, the
 same one I previously tested on Linux with GDB, just worked on real
 Mach without me having to make any additional changes to the glibc
 side, or even recompile it.

 But I did not stop there, and I got several of the core Hurd servers
 working!  Namely, these are ext2fs, exec, startup, auth, and proc
 servers. All of them but ext2fs are dynamically linked; ld
 aarch64.so.1 sucessfully locates and maps the programs themselves
 and their required dependencies, and Mach pages in code and data
 pages from ext2fs as they are accessed, transparently to the
 program, just as one would expect it to.

Be sure to read more from his announcement email.

Sergey also announced a new Alpine distro based on Hurd (it currently does not have a name). His goal is to add another Hurd distribution, which will force the Hurd to work with different software and hopefully fix more bugs. Alpine Linux also usually runs the latest software, so this new Hurd distribution will be for those who like living on the bleeding edge. He writes:

I have ported many Alpine packages to build with (i386, for now) GNU
 Mach, the Hurd, and glibc, replacing Linux and musl. If you want a
 specific number: as of yesterday, I have 299 installable packages; the
 number of source packages is of course several times less than that.
 Still, this includes things like curl, ncurses, nano, native binutils
 & gcc & mig, libffi, openrc, openssl, util-linux, busybox, apk-tools,
 ... and of course gnumach, hurd (with dependencies like libdaemon,
 parted, ...), and glibc. Importantly, all this cleanly bootstraps
 using the scripts/bootstrap.sh script that they provide; this is too
 somewhat like Flávio's scripts, but it uses the real full Alpine
 package definitions for e.g. GCC (patched by me for glibc / Hurd
 support).

 Above the kernel and libc, things remain much as they were in upstream
 Alpine: the system boots (will boot — I haven't tried it yet) with
 busybox init & OpenRC, and uses busybox as its basic userland. GNU
 software such as Bash is installable, too.

This new Hurd distribution currently does not have a mailing list, irc room, or website. If you are interesting in helping Sergei to develop it further, then please email bug-hurd@gnu.org.

Luca Dariz added userspace tests, which work with qemu. We currently test the Hurd in qemu on a GNU/Linux host. He also described how he currently uses the 64-bit Hurd. Perhaps you should follow that advice if you want to try running a 64-bit Hurd on qemu.

Manolo de Medici made a WIP patch series that gets qemu to run on the Hurd.

I organized a belated GNU/Hurd Christmas party. We had 6 or 7 attenders, which was pretty awesome! I was not able to record the event, so perhaps we should try for another meet perhaps at the end of Q2. If you would like to help me plan/organize/join such a party, then please email bug-hurd@gnu.org.

If you want to test if your favorite packages work on the Hurd and contribute towards making the full GNU system usable for a wider range of people, please check the contributing page.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

Samuel Thibault fixed gcc's Hurd's default pie and added static pie support. He also added a whatis command to GNU Mach's kernel debugger, which can determine what an address points to (a stack? a port? some kalloc? ...). He also added hurd-amd64 support to GCC.

Samuel requested that the Hurd team set up a continuous integration, so that when developers make code changes, they can be certain that they did not break anything. It turns out that the Hurd supports several different environments: 32 bit, 64 bit, 32-on-64 bit, ACPI, non-ACPI, SMP, non-SMP, Xen, etc. Apparently Flavio has a personal CI, but it is set up in a Debian independent way. If you are interested in helping the Hurd project set up a CI, then please get in touch!

Luca Dariz worked on adding some simple GNU Mach user-space tests . With a working MiG, a GNU/Linux machine can run make check in the GNU Mach source code, which will launch qemu to ensure that 32 bit (PAE and non PAE), 32 on 64 bit, and full 64 bit GNU Mach works. We currently do this testing on GNU/Linux, because qemu does not run on the Hurd.

Many people worked on the Hurd's new x86_64 bit support. A 64-bit debian buildd is set up, and we can bootstrap a chroot! The hurd-amd64 wanna-build infrastructure is also set up. We are having issues reliably building packages on a 64-bit Hurd, which lead Samuel to uncover and fix a proc leak.

Flavio Cruz improved GNU Mach's IPC by reordering mach_msg_type_t fields to byte align msgt_name and msgt_size. He also created a patch series to avoid message resizing for x86_64. He also removed untyped mach RPC code. GNU Mach uses typed IPC. The Hurd could support both typed and untyped, but it appears that the Hurd only uses typed RPC. So it seems best to remove any untyped RPC code.

Sergey Bugaev added GNU Mach entry re-coalescing support. Essentially, Mach was not always able to merge two vm entries that are made next to each other, which was slowing down ext2, bash, etc. Sergey allowed GNU Mach to merge entries in the common cases, which greatly helps ext2fs for instance.

Sergey is also working on porting the Ladybird web browser to the Hurd. The author of this post uses the netsurf web browser on the Hurd, which works on simple websites like wikipedia, but it badly renders javascript heavy websites, which makes many websites un-useable. If Sergey is successful in porting Ladybird, then Hurd users could start using sites like Github! It is worth noting that someone should update the Firefox port as well.

Sergey also started porting the Hurd to AArch64! While a port to RISC-V might be more exciting, it is worth mentioning that AArch64 is more established. What is interesting is that Sergey is already able to build Hurd servers for AArch64! Normally, in order to run the binaries, one would port GNU Mach to AArch64. Luckily for us, he turned to GDB and directly ran a 'Hello World' Hurd AArch64 binary on Linux! This helped him fix some bugs along the way. We still need to define the ABI and complete the GNU Mach port, but this is exciting news!

Tobias Platen started porting GNU Mach to Power9.

So if you want to test if your favorite packages work on the Hurd and contribute towards making the full GNU system usable for a wider range of people, please check the contributing page.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

Joan Lledo modified the PCI arbiter to prevent mapping I/O region files. He previously sent some patches to implement mapping region and ROM files using mmap(). However, a BAR region can represent either memory or I/O space, and only memory should be allowed to be mapped. Since I/O BARs only contain I/O addresses, he went ahead and prevented the mapping of I/O region files. The next step is to make IO spaces available for users through the pci-arbiter. He plans to add a new RPC that checks for permission and calls i386_io_perm_create(). Then it returns the resulting port.

Our Google summer of code student Vedant Tewari decided to port rust, and the rust porting effort is making good progress. The build process is a bit wonky, and Debian is using an older rust version. Check out the rust pull request that adds Hurd support!

Samuel worked on setting up PAE, which will eventually let us use more than 4GB of RAM on a 32-bit Hurd! It is also useful for the X86_64 architecture. He also fixed the jemalloc build.

Samuel was incredibly productive this quarter making the X86_64 bit port more stable. He fixed the 64-bit Hurd PIE build, and he got git working on the 64-bit port! Though a few of the git tests are failing on both X86_64 and the 32 bit port. He fixed the glibc build, which involved fixing pmap_remove and pmap_protect. He discovered that core dumping is currently causing problems on the 64-bit port, and he temporarily encourages people to disable core dumping. Samuel fixed some networking issues and a dpkg issue for the 64-bit port. It was hard to discover what the problem was, because the debugging tools have not been ported to the 64-bit port. He add some helpers to locking to fix some bugs, and he encourages other developers to help him fix the debugging tools for X86-64. It seems that most developers are currently running the 64-bit Hurd in a virtual machine and not in real hardware.

Luca Dariz got a patch series merged for the 64 bit port.

Sergey implemented MAP_EXCL and provided MAP_FIXED_NOREPLACE and MAP_TRYFIXED as aliases of (MAP_FIXED|MAP_EXCL) as well other mmap work. He explains:

MAP_FIXED is defined to silently replace any existing mappings at the address range being mapped over. However, this is dangerous and only rarely desired behavior.

Various Unix systems provide replacements or additions to MAP_FIXED.

• SerenityOS and Linux provide MAP_FIXED_NOREPLACE. If the address space already contains a mapping in the requested range, Linux returns EEXIST. SerenityOS returns ENOMEM, however that is a bug, as the MAP_FIXED_NOREPLACE implementation is intended to be compatible with Linux.

• DragonFly BSD, NetBSD, and OpenBSD provide MAP_TRYFIXED, but with different semantics. DragonFly BSD returns ENOMEM if the requested range already contains existing mappings. NetBSD does not return an error, but instead creates the mapping at a different address if the requested range contains mappings. OpenBSD behaves the same, but also notes that this is the default behavior even without MAP_TRYFIXED (which is the case on the Hurd too).

Since the Hurd leans closer to the BSD side, add MAP_EXCL as the primary API to request the behavior of not replacing existing mappings. Declare MAP_FIXED_NOREPLACE and MAP_TRYFIXED as aliases of (MAP_FIXED|MAP_EXCL), so any existing software that checks for either of those macros will pick them up automatically. For compatibility with Linux, return EEXIST if a mapping already exists.

Damien Zammit added a USB mass storage translator via rumpusbdisk. Though it has some issues as he explains:

Netdde sneems to exhibit a bug when running ifdown /dev/eth0 simultanously to running the rumpusbdisk translator, because to the two devices share the same IRQ.

Damien also worked on the Hurd's SMP support (much of his SMP contributions is based on the earlier work done by Almudena Garcia):

• He tweaked GNU Mach's scheduler, and he merged three GNU Mach commits.

• He added a show all runqs command to GNU Mach's kernel debugger.

• He also improved SMP in GNU Mach by storing the struct processor in a percpu area and avoiding an expensive cpu_number every call of current_processor(), as well as getting the cpu_number from an offset in the percpu area. Further improvements can be made by using other percpu areas. It was untested on 64 bit.

• Damien also taught GNU Mach to use the x86 CPUID instruction to get the CPU ID for speed. He reduced the time it takes to get the CPUID. He made it 100 times faster!

• He mentioned some issues: 60% of the time, booting a 32 bit Hurd, with SMP enabled, fails to boot (sometimes apparently getting stuck in the rumpdisk). When it does boot, it is not particularly stable and likely to crash.

Essentially, the SMP work is progressing, but it is not ready for production use. His recent work made the non-SMP faster, and a 32 bit Hurd, with SMP enabled and only one core, appears relatively stable (but slow to boot). The 32-bit SMP enabled Hurd may soon be as fast as the non-SMP Hurd. Eventually the SMP enabled Hurd will be faster than a non-SMP Hurd.

Flavio Cruz halved the size of mach_msg_type_long_t, from 16 to 8 bytes. He also simplified the overall 64bit RPC ABI, removing "holes" in mach_msg_type_t or mach_msg_type_long_t, which prevents possible leakages to userspace.

Some Hurd people talked to Kent Overstreet, the author of bcachefs to discuss the possibility of porting Linux's newest filesystem to the Hurd; the conversation was recorded. While most Hurd developers believe that it would possible to port bcachefs to the Hurd, all agree that it would be difficult to port and hard to maintain. No Hurd developers are currently planning or working on porting bcachefs to the Hurd. But perhaps you want to?

So if you want to test if your favorite packages work on the Hurd and contribute towards making the full GNU system usable for a wider range of people, please check the contributing page.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

It is with huge pleasure that the Debian GNU/Hurd team announces the release of Debian GNU/Hurd 2023.

This is a snapshot of Debian "sid" at the time of the stable Debian "bookworm" release (June 2023), so it is mostly based on the same sources. It is not an official Debian release, but it is an official Debian GNU/Hurd port release.

Read the announcement email.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

It is with huge pleasure that the Debian GNU/Hurd team announces the release of Debian GNU/Hurd 2021.

This is a snapshot of Debian "sid" at the time of the stable Debian "bullseye" release (August 2021), so it is mostly based on the same sources. It is not an official Debian release, but it is an official Debian GNU/Hurd port release.

Read the announcement email.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

It is with huge pleasure that the Debian GNU/Hurd team announces the release of Debian GNU/Hurd 2019.

This is a snapshot of Debian "sid" at the time of the stable Debian "buster" release (July 2019), so it is mostly based on the same sources. It is not an official Debian release, but it is an official Debian GNU/Hurd port release.

Read the announcement email.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

Joan Lledó completed a PCI Arbiter for the GNU/Hurd, and Damien Zammit helped polish it. This is a significant development and accomplishment! PCI stands for Peripheral Component Interconnect, and it is a standard that allows many computer peripherals to communicate together with the rest of the system smoothly. Of course, the GNU/Hurd intends to take this further by allowing ordinary users to safely access PCI cards! You can learn more about it in Samuel fosdem talk. http://lists.gnu.org/archive/html/bug-hurd/2018-10/msg00029.html

Joan Lledo` updated the GNU/Hurd lwip translator to work with the latest lwip. As a reminder lwip is a lightweight TCP/IP networking stack. The GNU/Hurd lwip translator provides a complete replacement to GNU/Hurd's pfinit. http://lists.gnu.org/archive/html/bug-hurd/2018-11/msg00062.html

Damien Zammit created an ACPI translator. This translator provides a translator for mounting x86 ACPI tables under a path as read-only files. It is needed so that other things that depend on ACPI to find the base address such as Intel's IOMMU (DMAR table), memory mapped PCI space (MCFG table) etc, can be discovered in userspace. Otherwise, this functionality would need to be built into gnumach which would be a burden to maintain. http://lists.gnu.org/archive/html/bug-hurd/2018-11/msg00049.html

Damien Zammit worked on allowing libstore to open non-mach devices, which is in preparation for rump kernel disk access. http://lists.gnu.org/archive/html/bug-hurd/2018-12/msg00050.html

Samuel Thibault allowed non-privileged users to mount their own tmpfs. It turned out to be a permission issue and a trivial fix. http://lists.gnu.org/archive/html/bug-hurd/2018-11/msg00012.html

Samuel fixed a bfs issue with /proc not properly mounting. https://lists.debian.org/debian-hurd/2018/10/msg00007.html

Samuel Thibault enabled LLVM to support the Hurd. This can hopefully pave the way to use LLVM sanitizers on the existing GNU/Hurd codebase. https://www.phoronix.com/scan.php?page=news_item&px=GNU-Hurd-LLVM-Clang

Work toward porting Rust and Go to the GNU/Hurd is ongoing: https://lists.debian.org/debian-hurd/2018/11/msg00020.html

Svante Signell worked on adding POSIX file record locking support. http://lists.gnu.org/archive/html/bug-hurd/2018-11/msg00058.html http://lists.gnu.org/archive/html/bug-hurd/2016-12/msg00047.html

So if you want to test if your favorite packages work on the Hurd and contribute towards making the full GNU system usable for a wider range of people, please get in contact -- and maybe already grab the source code.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

It is with huge pleasure that the Debian GNU/Hurd team announces the release of Debian GNU/Hurd 2017.

This is a snapshot of Debian "sid" at the time of the stable Debian "stretch" release (May 2017), so it is mostly based on the same sources. It is not an official Debian release, but it is an official Debian GNU/Hurd port release.

Read the announcement email.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

We're pleased to announce new releases!

• GNU Hurd 0.9, NEWS:

  Version 0.9 (2016-12-18)
  
  
  The 'boot' program can now be run as unprivileged user, allowing any
  user to create unprivileged Subhurds.
  
  
  An ethernet multiplexer (eth-multiplexer translator) has been merged
  into this repository.  This is a network multiplexer that makes
  available virtual interfaces, and routes traffic between these and a
  real ethernet interface.  It uses the Berkeley Packet Filter library
  (libbpf), which has also been merged.  The ethernet multiplexer now
  generates and uses stable pseudo-random ethernet addresses for the
  virtual interfaces.
  
  
  As usual, bugs have been fixed throughout the code, notably in
  libpager and ext2fs which now gracefully handles running out of space.
  Further compatibility fixes have been applied (for compliance to
  standards such as POSIX).
  

  Release tarballs may be downloaded from ftp://ftp.gnu.org/gnu/hurd/, http://ftp.gnu.org/gnu/hurd/, or checked out of Git, https://git.savannah.gnu.org/cgit/hurd/hurd.git. SHA1 checksums:

  7e6f406e5202501216a0da4b4ee7914f1e0a7552  hurd-0.9.tar.bz2
  ffa8d40a99835824a0228bf54570c054d7fe8bf0  hurd-0.9.tar.bz2.sig
  ef999452b794d7239a5ed98999def51bf11c8c17  hurd-0.9.tar.gz
  5f5d34bbbe8cccafbe79f13103d7e48b3a2baddf  hurd-0.9.tar.gz.sig
  

  The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed: documentation, what is the GNU Hurd.

• GNU Mach 1.8, NEWS:

  Version 1.8 (2016-12-18)
  
  
  The memory management system was extensively reworked.  A new type for
  physical addresses is now used where appropriate, and the system can
  make use of the high memory segment.  Many paging issues have been
  addressed, and as a result the system handles low memory situations
  more gracefully now.
  
  
  The virtual memory system now uses a red-black tree for allocations,
  and as a result it now supports tasks with tens of thousands of
  mappings.
  
  
  Debugging and error reporting has been improved.  Among other things
  the VM maps are now augmented with names that are used in error
  messages, panics and assertions point to their locations, the lock
  debugging mechanism has been fixed, and the kernel debugger can now
  inspect stack traces reaching into the machine-dependent bits
  implemented in assembler.
  
  
  As usual, bugs have been fixed throughout the code, including minor
  issues with the gsync synchronization mechanism which is now used for
  the internal locks in the GNU C Library (glibc).
  
  
  The deprecated external memory management interface has been removed.
  
  
  The partial ACPI support has been removed.
  

  Release tarballs may be downloaded from ftp://ftp.gnu.org/gnu/gnumach/, http://ftp.gnu.org/gnu/gnumach/, or checked out of Git, https://git.savannah.gnu.org/cgit/hurd/gnumach.git. SHA1 checksums:

  4b59c7f7bc814576d2b88c43c0cdba292824f230  gnumach-1.8.tar.bz2
  e6262e991a1e056bb87741a9456811cf73e8f7cd  gnumach-1.8.tar.bz2.sig
  8cbebcbee624c64d926de8779272821c67663da5  gnumach-1.8.tar.gz
  28c4a65db3c04bf7508b74a187a3d6aae3a5ce31  gnumach-1.8.tar.gz.sig
  

  GNU Mach is the GNU distribution of the Mach microkernel, upon which a GNU Hurd system is based. The microkernel provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed: documentation.

• GNU MIG 1.8, NEWS:

  Version 1.8 (2016-12-18)
  
  
  A spurious warning in the generated code has been fixed.
  

  Release tarballs may be downloaded from ftp://ftp.gnu.org/gnu/mig/, http://ftp.gnu.org/gnu/mig/, or checked out of Git, https://git.savannah.gnu.org/cgit/hurd/mig.git. SHA1 checksums:

  f765881d6ed4e883372eee52fd7842e7048a3da8  mig-1.8.tar.bz2
  2091b6632176eeba1dac524d0ae939334ed51fdb  mig-1.8.tar.bz2.sig
  40ae7a5a12e3e5669a2c449be7ebe53c72c90b3a  mig-1.8.tar.gz
  054ca62368fb7d8e95ca1447510905e3df8906d8  mig-1.8.tar.gz.sig
  

  GNU MIG is the GNU distribution of the Mach 3.0 Interface Generator (MIG). This tool translates Remote Procedure Call (RPC) definition files to C code, and is required to compile any packages that are receiving or invoking RPCs, such as GNU Mach, GNU Hurd, and the GNU C Library (glibc) when compiled for the Hurd. More detailed: documentation.

• glibc-2.23-hurd+libpthread-20161218

  Based on the glibc 2.23 release, we include additional changes for GNU Hurd support, and bundle GNU Hurd's libpthread.

  Snapshot tarballs may be downloaded from ftp://alpha.gnu.org/gnu/hurd/, http://alpha.gnu.org/gnu/hurd/, or checked out of Git, https://git.savannah.gnu.org/cgit/hurd/glibc.git and https://git.savannah.gnu.org/cgit/hurd/libpthread.git. SHA1 checksums:

  55c9b6c61991a9ea585f019c787fe0e1da756cd4  glibc-2.23-hurd+libpthread-20161218.tar.bz2
  1475fff2029fcd2c655d6ea05af5efa74d224b4f  glibc-2.23-hurd+libpthread-20161218.tar.bz2.sig
  870425f4398b514ecac06e88fc21e13536eece4f  glibc-2.23-hurd+libpthread-20161218.tar.gz
  e8c9c6ba34cd4bbabb8fadd28f335430ca88ff0b  glibc-2.23-hurd+libpthread-20161218.tar.gz.sig
  

  The GNU C Library (glibc) implements a system's standard library functions (as described by ISO C, and POSIX, for example). An important part of the Hurd actually resides in glibc: here, the system interfaces are implemented on top of the Hurd IPC protocols. This is different to the Linux port, where most simple system interfaces are in fact simply forwarded to/implemented as system calls.

Many thanks to all the people who are helping!

If you want to give the Hurd a try, you may easily do so with Debian GNU/Hurd.

The GNU Hurd system currently runs on 32-bit x86 machines. To compile the Hurd, you need a toolchain configured to target i?86-gnu; you cannot use a toolchain targeting GNU/Linux.

Please read the FAQ. Bug reports should be sent to bug-hurd or filed on http://savannah.gnu.org/bugs/?group=hurd. Requests for assistance should be sent to help-hurd or filed on http://savannah.gnu.org/support/?group=hurd. You can also find us on the Freenode IRC network in the #hurd channel.

We're pleased to announce new releases!

• GNU Hurd 0.8, NEWS:

  Version 0.8 (2016-05-18)
  
  
  The netfs library is using the lockless reference-counting primitives
  for both peropen and node objects now, and the global reference
  counting lock has been removed.
  
  
  The integer hashing library gained a new interface to use non-integer
  keys.  It is now used in libdiskfs' and nfs' node cache, and the ftpfs
  translator.
  
  
  Several bugs in our native fakeroot tool have been fixed improving
  stability and correctness of the translation.
  
  
  The devnode translator and the hurd-slab library have been merged into this
  repository.
  
  
  The code has been cleaned up, and we fixed numerous bugs, most notably
  a crash in pfinet, a locking bug in libdiskfs, and an out-of-bounds
  access in ext2fs' block cache.
  

  Release tarballs may be downloaded from ftp://ftp.gnu.org/gnu/hurd/, http://ftp.gnu.org/gnu/hurd/, or checked out of Git, https://git.savannah.gnu.org/cgit/hurd/hurd.git. SHA1 checksums:

  38585aed93645704477d91d01136e1ae750a5ecb  hurd-0.8.tar.bz2
  531d5035427830e87828a79bf6794531250784d0  hurd-0.8.tar.bz2.sig
  6383479f30933d760c6d981fdd37df27adb5f0bb  hurd-0.8.tar.gz
  63f58d392cb6e0c0ebd71e725938a13a5cab2392  hurd-0.8.tar.gz.sig
  

  The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed: documentation, what is the GNU Hurd.

• GNU Mach 1.7, NEWS:

  Version 1.7 (2016-05-18)
  
  
  The code has been updated to work with newer versions of GCC, and numerous bugs
  have been fixed throughout the code, including a pageout deadlock.  The code
  uses integer types from <stdint.h> now instead of the old Mach types.
  
  
  The VM cache policy change has been merged.  The kernel now caches
  unreferenced VM objects unconditionally instead of using a fixed
  limit.
  
  
  The physical page allocator of the X15 kernel has been integrated, and
  is now used directly by the slab allocator.  This increases the kernel
  heap addressing important scalability issues.
  
  
  The gsync synchronization mechanism was added, similar to the Linux kernel's
  futexes, to allow efficient and powerful userland synchronization.
  
  
  Support for profiling kernel code from userland through sampling was added.
  

  Release tarballs may be downloaded from ftp://ftp.gnu.org/gnu/gnumach/, http://ftp.gnu.org/gnu/gnumach/, or checked out of Git, https://git.savannah.gnu.org/cgit/hurd/gnumach.git. SHA1 checksums:

  4438c7c10f8eef019ada45b749c0796d620d08de  gnumach-1.7.tar.bz2
  6cdf299118066e3280dcc68f75477659fc783f7d  gnumach-1.7.tar.bz2.sig
  5474b2cdc01cb002149db08d745fdab741470c65  gnumach-1.7.tar.gz
  018aa0551e87c4b5eeb900934491811f46ab8b78  gnumach-1.7.tar.gz.sig
  

  GNU Mach is the GNU distribution of the Mach microkernel, upon which a GNU Hurd system is based. The microkernel provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed: documentation.

• GNU MIG 1.7, NEWS:

  Version 1.7 (2016-05-18)
  
  
  MIG now has a test suite.  It includes a set of valid and invalid
  definition files that MIG will try to process.  For valid
  definitions, GCC will compile the stubs to check if valid C code was
  generated.
  
  
  The generated code uses integer types from <stdint.h> now instead of
  the old Mach types.
  
  
  Code that was hard-coding the word size has been identified and
  fixed.
  
  
  Support for the obsolete kinds of RPC routines 'functions',
  'procedures', and 'simple procedures' has been removed.
  
  
  MIG now emits code that casts objects translated from capabilities
  to the correct C type.
  

  Release tarballs may be downloaded from ftp://ftp.gnu.org/gnu/mig/, http://ftp.gnu.org/gnu/mig/, or checked out of Git, https://git.savannah.gnu.org/cgit/hurd/mig.git. SHA1 checksums:

  25d87f0271678d044a8af1f45492a96bee32e486  mig-1.7.tar.bz2
  481dce92b8eb718231bf9d409c0e0c9337dc1f90  mig-1.7.tar.bz2.sig
  f1bd05d1b353653f49dbbb44a4624e65c7be0a2e  mig-1.7.tar.gz
  59f71517cd1be26635a27da423bcf75e2399a42e  mig-1.7.tar.gz.sig
  

  GNU MIG is the GNU distribution of the Mach 3.0 Interface Generator (MIG). This tool translates Remote Procedure Call (RPC) definition files to C code, and is required to compile any packages that are receiving or invoking RPCs, such as GNU Mach, GNU Hurd, and the GNU C Library (glibc) when compiled for the Hurd. More detailed: documentation.

• glibc-2.19-hurd+libpthread-20160518

  Based on the glibc 2.19 release, we include additional changes for GNU Hurd support, and bundle GNU Hurd's libpthread.

  Snapshot tarballs may be downloaded from ftp://alpha.gnu.org/gnu/hurd/, http://alpha.gnu.org/gnu/hurd/, or checked out of Git, https://git.savannah.gnu.org/cgit/hurd/glibc.git and https://git.savannah.gnu.org/cgit/hurd/libpthread.git. SHA1 checksums:

  3722b7f52aac89c66f064e1e6d19ec9b92ffc9e0  glibc-2.19-hurd+libpthread-20160518.tar.bz2
  69dfe1297013056b4b0d6436a1b3906c1bb67a52  glibc-2.19-hurd+libpthread-20160518.tar.bz2.sig
  2795bacc85c799a028577089c422ff4ef9b876bc  glibc-2.19-hurd+libpthread-20160518.tar.gz
  a7af1d2500f35413003f08801e258f3666dfcb87  glibc-2.19-hurd+libpthread-20160518.tar.gz.sig
  

  The GNU C Library (glibc) implements a system's standard library functions (as described by ISO C, and POSIX, for example). An important part of the Hurd actually resides in glibc: here, the system interfaces are implemented on top of the Hurd IPC protocols. This is different to the Linux port, where most simple system interfaces are in fact simply forwarded to/implemented as system calls.

Many thanks to all the people who are helping!

If you want to give the Hurd a try, you may easily do so with Debian GNU/Hurd.

The GNU Hurd system currently runs on 32-bit x86 machines. To compile the Hurd, you need a toolchain configured to target i?86-gnu; you cannot use a toolchain targeting GNU/Linux.

Please read the FAQ. Bug reports should be sent to bug-hurd or filed on http://savannah.gnu.org/bugs/?group=hurd. Requests for assistance should be sent to help-hurd or filed on http://savannah.gnu.org/support/?group=hurd. You can also find us on the Freenode IRC network in the #hurd channel.

We're pleased to announce new releases!

• GNU Hurd 0.7, NEWS:

  Version 0.7 (2015-10-31)
  
  
  The node cache in ext2fs has been improved, generalized, and moved to
  libdiskfs.  It is now also used by isofs and fatfs.
  
  
  The native fakeroot tool has been greatly improved.  It now handles
  named sockets, and multiple corner cases related to permissions were
  identified and fixed.
  
  
  A new utility `rpcscan' has been introduced.  It scans Mach servers
  and displays the RPCs handled by the associated demuxer.
  
  
  A long-standing synchronization issue involving the filesystem
  translators, libdiskfs, and libpager has been identified and fixed.
  
  
  The code has been updated to work with newer versions of the compiler
  and libc, and numerous bugs have been fixed throughout the code.
  

  Release tarballs may be downloaded from ftp://ftp.gnu.org/gnu/hurd/, http://ftp.gnu.org/gnu/hurd/, or checked out of Git, https://git.savannah.gnu.org/cgit/hurd/hurd.git. SHA1 checksums:

  a735a07687f7996face3bd310af2254192a02f40  hurd-0.7.tar.bz2
  d10b3c1de191ac88425aa30a03c4130e2a883b14  hurd-0.7.tar.bz2.sig
  62032e04bf6b22e4c874772f1f77d5678d916054  hurd-0.7.tar.gz
  7fafd66e0003ea3768f76bd597e617bdc202e312  hurd-0.7.tar.gz.sig
  

  The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed: documentation, what is the GNU Hurd.

• GNU Mach 1.6, NEWS:

  Version 1.6 (2015-10-31)
  
  
  The code has been updated to work with newer versions of the compiler,
  and numerous bugs have been fixed throughout the code.
  
  
  The lock debugging infrastructure has been revived and improved, and
  many locking issues have been fixed.
  
  
  The IPC tables and the hash table mapping objects to IPC entries have
  been replaced by radix trees.  This addresses a scalability issue, as
  IPC tables required huge amounts of continuous virtual kernel memory.
  
  
  The kernel now allows non-privileged users to wire a small amount of
  memory.
  
  
  A bug hindering the eviction of inactive pages by the pageout daemon
  has been identified and fixed.
  
  
  The kernel now keeps timestamps relative to the system boot time.
  Among other things this fixes bogus uptime readings if the system time
  is altered.
  
  
  A reference leak in the exception handling mechanism has been
  identified and fixed.
  
  
  ANSI escape sequences are now handled when using `printf'.  This fixes
  the formatting of messages printed by various Linux drivers.
  

  Release tarballs may be downloaded from ftp://ftp.gnu.org/gnu/gnumach/, http://ftp.gnu.org/gnu/gnumach/, or checked out of Git, https://git.savannah.gnu.org/cgit/hurd/gnumach.git. SHA1 checksums:

  73e09c43955ef2e3459b2877b5e6d6bbe517b8c3  gnumach-1.6.tar.bz2
  96ff426b3b94acf327a88f25c80ab5b5f26ed94a  gnumach-1.6.tar.bz2.sig
  448cd88974a5264736c900691c9ab62a810aff28  gnumach-1.6.tar.gz
  e06e733ad11f2e048dd9ad3348c2d3100be26078  gnumach-1.6.tar.gz.sig
  

  GNU Mach is the GNU distribution of the Mach microkernel, upon which a GNU Hurd system is based. The microkernel provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed: documentation.

• GNU MIG 1.6, NEWS:

  Version 1.6 (2015-10-31)
  
  
  MIG now emits RPC lookup functions that are declared `static inline'
  improving compatibility with newer dialects of C.
  

  Release tarballs may be downloaded from ftp://ftp.gnu.org/gnu/mig/, http://ftp.gnu.org/gnu/mig/, or checked out of Git, https://git.savannah.gnu.org/cgit/hurd/mig.git. SHA1 checksums:

  a9a4b5666834afe8fb861453c5b3ef324201f1d3  mig-1.6.tar.bz2
  93562c45bbda40ad31f74f6f2fd0c064ef8f0ec5  mig-1.6.tar.bz2.sig
  6e937a35229da02e9e739d75a03020e24a1b5297  mig-1.6.tar.gz
  fc25bb9652406675fed63c4581493a6fc39d9690  mig-1.6.tar.gz.sig
  

  GNU MIG is the GNU distribution of the Mach 3.0 Interface Generator (MIG). This tool translates Remote Procedure Call (RPC) definition files to C code, and is required to compile any packages that are receiving or invoking RPCs, such as GNU Mach, GNU Hurd, and the GNU C Library (glibc) when compiled for the Hurd. More detailed: documentation.

• glibc-2.19-hurd+libpthread-20151031

  Snapshot tarballs may be downloaded from ftp://alpha.gnu.org/gnu/hurd/, http://alpha.gnu.org/gnu/hurd/, or checked out of Git, https://git.savannah.gnu.org/cgit/hurd/glibc.git and https://git.savannah.gnu.org/cgit/hurd/libpthread.git. SHA1 checksums:

  5b709297f8622444695f13723f77dfc8754b8ed9  glibc-2.19-hurd+libpthread-20151031.tar.bz2
  b970e604368fd80420ef029bb1c86fc2f7b2c382  glibc-2.19-hurd+libpthread-20151031.tar.bz2.sig
  68f02cd3890654588183539428253a12ff98ea0d  glibc-2.19-hurd+libpthread-20151031.tar.gz
  da8b38a9a9914a2dedba82a0cf353a4ce0ea30e7  glibc-2.19-hurd+libpthread-20151031.tar.gz.sig
  

  The GNU C Library (glibc) implements a system's standard library functions (as described by ISO C, and POSIX, for example). An important part of the Hurd actually resides in glibc: here, the system interfaces are implemented on top of the Hurd IPC protocols. This is different to the Linux port, where most simple system interfaces are in fact simply forwarded to/implemented as system calls.

Many thanks to all the people who are helping!

If you want to give the Hurd a try, you may easily do so with Debian GNU/Hurd.

The GNU Hurd system currently runs on 32-bit x86 machines. To compile the Hurd, you need a toolchain configured to target i?86-gnu; you cannot use a toolchain targeting GNU/Linux.

Please read the FAQ. Bug reports should be sent to bug-hurd or filed on http://savannah.gnu.org/bugs/?group=hurd. Requests for assistance should be sent to help-hurd or filed on http://savannah.gnu.org/support/?group=hurd. You can also find us on the Freenode IRC network in the #hurd channel.

It is with huge pleasure that the Debian GNU/Hurd team announces the release of Debian GNU/Hurd 2015.

This is a snapshot of Debian "sid" at the time of the stable Debian "jessie" release (April 2015), so it is mostly based on the same sources. It is not an official Debian release, but it is an official Debian GNU/Hurd port release.

Read the announcement email.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

• GNU Hurd 0.6: announcement, NEWS
• GNU Mach 1.5: announcement, NEWS
• GNU MIG 1.5: announcement, NEWS

If you want to give the Hurd a try, you may easily do so with Debian GNU/Hurd.

Please read the FAQ. Bug reports should be sent to bug-hurd or filed on http://savannah.gnu.org/bugs/?group=hurd. Requests for assistance should be sent to help-hurd or filed on http://savannah.gnu.org/support/?group=hurd. You can also find us on the Freenode IRC network in the #hurd channel.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

Which day could be better suited for publishing a set of Hurd package releases than the GNU project's 30th birthday?

... and here we have our birthday presents:

• GNU Hurd 0.5: announcement, NEWS
• GNU Mach 1.4: announcement, NEWS
• GNU MIG 1.4: announcement, NEWS

These new releases bundle bug fixes and enhancements done since the last releases more than a decade ago; really too many (both years and improvements) to list them individually, but please see the NEWS files. Many thanks to all the people who are helping!

If you want to give the Hurd a try, you may easily do so with Debian GNU/Hurd.

Please read the FAQ. Bug reports should be sent to bug-hurd or filed on http://savannah.gnu.org/bugs/?group=hurd. Requests for assistance should be sent to help-hurd or filed on http://savannah.gnu.org/support/?group=hurd. You can also find us on the Freenode IRC network in the #hurd channel.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

It is with huge pleasure that the Debian GNU/Hurd team announces the release of Debian GNU/Hurd 2013. This is a snapshot of Debian "sid" at the time of the Debian "wheezy" release (May 2013), so it is mostly based on the same sources. It is not an official Debian release, but it is an official Debian GNU/Hurd port release.

The installation ISO images can be downloaded from Debian Ports in the usual three Debian flavors: NETINST, CD, DVD. Besides the friendly Debian installer, a pre-installed disk image is also available, making it even easier to try Debian GNU/Hurd.

Debian GNU/Hurd is currently available for the i386 architecture with more than 10.000 software packages available (more than 75% of the Debian archive, and more to come!).

Please make sure to read the configuration information, the FAQ, and the translator primer to get a grasp of the great features of GNU/Hurd.

Due to the very small number of developers, our progress of the project has not been as fast as other successful operating systems, but we believe to have reached a very decent state, even with our limited resources.

We would like to thank all the people who have worked on GNU/Hurd over the past decades. There were not many people at any given time (and still not many people today, please join!), but in the end a lot of people have contributed one way or another. Thanks everybody!

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

In November 2012, we finished the libthreads (cthreads) to libpthread (POSIX Threads) conversion. Converting the Hurd libraries to the pthread interfaces allows linking them together with other libraries that use this standard threading interface themselves. This project once was begun by Vicente Hernando Ara, and later continued by Barry deFreese, Thomas DiModica, Thomas Schwinge, Samuel Thibault, Pino Toscano, and now brought to completion by Richard Braun, who could not be scared by having to resolve the last remaining tricky issues before the transition could be completed.

Cyril Roelandt shared a patch series to fix double mutex unlocking problems. He found these using a simple script for Coccinelle, which is a static code analysis tool. We hope to see more such changes in the future, and we're always interested in hearing people who have experience with similar tools, for example to resolve other locking issues.

Thomas Schwinge together with Richard Braun and Samuel Thibault debugged and fixed a deadlock related to signal delivery, resulting from a regression due to earlier changes.

Also Samuel Thibault provided new installation CDs and a new QEMU image. Additionally to using pthreads, these now offer keyboard layout configuration.

In glibc, Pino Toscano implemented syncfs which ensures that all data in the filesystem gets written to disk, as well as support in procfs for statfs.

Thomas Schwinge improved the hardware compatibility of the Hurd by identifying and backporting some changes contained in Linux 2.0.40, which prevents data corruption due to a miscalculation of the size of medium-sized disks reporting 15 heads instead of 16. This fix was part of an effort to get Hurd running using a solid-state disk. Samuel Thibault improved network card detection on busses other than 0 and 2.

Several people ported and fixed packages, further increasing the number of Debian packages that work on the Hurd: Svante Signell ported mlocate-0.25, gnat-gps, libpst, libetpan, spl, dovecot, xplc, parrot, x86info, atlas, rrdtool, gdb, yodl, and fixed ntpdate to work again and improved the error handling in pflocal. Pino Toscano added patches for procfs, ptrace, fsync on stdout, muntrace, ulimit, glibc which among others improve POSIX conformance, making it easier to write programs which work on GNU/Hurd and GNU/Linux. And he made the test pass for FIFO sockets with mknod and added a size parameter to tmpfs and a version suffix option for GNU Mach's configure script. Cyril Roelandt fixed a ps bug, a documentation typo in ps and a missing linker flag in procfs. Matthew Leach fixed a compilation error with older GCC versions due to duplicate type definition. Ole Streicher fixed a bug in the Makefile of ftools-fv which was exposed by testing on Hurd. Samuel Thibault removed the out-of-date floppy-warnings in the debian installer.

So if you want to test if your favorite packages work on the Hurd and contribute towards making the full GNU system usable for a wider range of people, please get in contact -- and maybe already grab the source code.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

Google Summer of Code

Jérémie Koenig released the final report on his Google Summer of Code project Java on Hurd along with a summary of his changes and the challenges he faced. In a similar track, Samuel Thibault merged the slab branch, concluding Maksym Planeta's Goggle Summer of Code project on an improved memory allocator.

Pino Toscano improved the Hurd implementations of nanosleep, ptsnamer, getloginr, getgroups, and sendto, for POSIX compliance.

Barrier of Entry

Samuel Thibault, Ludovic Courtès and Thomas Schwinge reduced the barrier of entry into hacking the Hurd.

As part of this, Samuel prepared DDE in incubator, making about half the Linux kernel 2.6.29.6's network drivers compile on the Hurd, together with a netdde debian package and testing notes.

Ludovic contributed a continuous testing framework using a Nix-based GNU QEMU image. Thanks to his work, we now have automatic tests (background).

Thomas on the other hand moved the translators cvsfs and smbfs into the incubator Git repository, as well as libfuse, reducing the barrier of entry to improving them, so integrating cvs and samba in the filesystem and using FUSE translators can be stabilized more easily. Also he improved the Hurd build system, removing automatically generated files from the source repository, as now running autoreconf is all you need to create them.

Roland McGrath merged many glibc changes for upstream inclusion, reducing the maintenance load for our regular glibc development work.

The Core of the Hurd

Ludovic Courtès, Maksym Planeta, Samuel Thibault and Richard Braun took a dive into the core of the Hurd. Ludovic fixed invalid port deallocation in `symlink' and made console-run resilient against missing /dev/console. Maksym tested the performance of tmpfs, showing a speedup for apt calls from 22 seconds with ramdisk and 32 seconds with ext2fs to 16 seconds with tmpfs for apt invocations, showing the possible wins due to going deep. An obvious use case for tmpfs are faster Hurd LiveCDs. Samuel made it easier to dive in by improving debugging in GNU Mach. The debugger is now aware of the difference between kernel space and user space. This should substantially reduce the development time for features in Mach by giving nicer stack traces. And in the deepest core of the Mach, Richard improved memory mapping with a red-black tree, which should speed up memory access.

Porting

As in the previous quarters, we also saw lots of ported packages, including Richard's work on libpcap which brought wireshark and pcap_inject for easier network testing, libtool thanks to Samuel Thibault and Peter O'Gorman, gnat by Svante Signell for Ada support (a language used in many mission-critical applications such as automotive and aerospace, offering features like strong typing, modularity, run-time checking and parallel processing), and iconx thanks to Samuel Thibault, which fulfills a requirement of tests for many packages, among them glib - and allowed Svante Signell to port the literate programming language noweb and ifupdown. Also Thomas DiModica merged the cthreads to pthreads patch and added a branch for it to make it easier to work on getting Hurd to use the more current pthreads.

With his Debian GNU/Hurd maintainer hat on, Samuel Thibault posted some new bits from the Debian GNU/Hurd porters.

And now, as a final note, we want to share a story about real-life debugging on a Hurd system; IRC, freenode, #hurd, 2012-03-02:

<youpi> yay GNU/Hurd  
<youpi> I have added i_translator check in e2fsck, it was missing  
<youpi> I had a volume that was keeping making ext2fs crash  
<youpi> with a reproductible scenario  
<youpi> could easily work out it was i_translator, then add a
  check to e2fsck, run it, which indeed fixed, them, and voilà,
  ext2fs was working again
<youpi> all that on the same machine with *no* system reboot  
<youpi> just ext2fs restart :)

So if you want to experience enjoyable debugging of code deep in the core of your system, please get in contact -- and maybe already grab the source code.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

This quarter, Ludovic Courtès contributed a continuously-built Nix-based QEMU image, raising the count of GNU/Hurd distributions to three: Debian GNU/Hurd, Arch Hurd, and now Nix. His build is still pretty basic, but a step into the right direction: continuous integration is a great facility for automated testing.

Samuel Thibault followed suit with a new Debian GNU/Hurd disk set as a christmas gift, and identified three easy porting cases with solutions:

• undefined reference to dl_*: add -ldl for building
• undefined reference to main: missing gnu* case in the linking part of configure.ac or .in
• undefined reference to clock_gettime or crypt: add -lrt or -lcrypt

These should help all those who want to help porting packages.

Maksym Planeta and Richard Braun finished integration of the slab allocator. From IRC, freenode, #hurd, 2011-11-14:

<braunr> there shouldn't be any noticeable difference [...]
<braunr> a bit less fragmentation  
<braunr> more memory can be reclaimed by the VM system  
<braunr> there are debugging features  
<braunr> it's SMP ready  
<braunr> and overall cleaner than the zone allocator  
<braunr> although a bit slower on the free path (because of
  what's performed to reduce fragmentation)  
<braunr> but even "slower" here is completely negligible

This also concludes our first FOSS Factory project -- one bounty has been redeemed, more are waiting.

Sergio Lopez documented his work on better memory management and memfs, making it easier for other hackers to join in working on that topic.

Our hackers also used the quarter for porting a good number of packages and fixing bugs. After fixing quirks in the Hurd's memory management system, Sergio Lopez reported success building webkitgtk+, whose build stresses the available memory resources on a 32-bit architecture to a large extent. Svante Signell was busy, too: pax, abiword, syslog-ng, ecl, fakeroot, daemon, and procps, e2fsprogs' quota. Samuel Thibault handled packagekit, evolution, emacs23, gcc-4.7, and iceweasel (firefox). Bouju Alain submitted a patch to support /proc/cpuinfo. Ludovic Courtès contributed a patch to allow for /hurd/init being symlink, made the Hurd build with glibc 2.14+, and worked with the GNU coreutils team on a few issues. Pino Toscano improved recvfrom with NULL address ports. Maksym Planeta continued working on tmpfs. Samuel Thibault turned /dev/random and /dev/urandom into native translators, modernized libtool's configuration, mknod's cleanup in error cases, fixed POSIX 2008 visibility, and fixed an issue in setresuid that broke sudo. Pino Toscano and Thomas Schwinge improved key handling in libpthread. Guillem Jover fixed Mach's int vs. long discrepancy, which takes us the first step towards porting the system to x86 64.

If you want to join us in our journey to realize more of the promises of the architecture of the Hurd, please get in contact -- and maybe already grab the source code and have fun hacking on Free Software!

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

In the third quarter of 2011, the Arch Hurd hackers packaged DDE (Device Driver Environment), so a subset of the Linux 2.6 device drivers can now easily be run as user-space processes on Arch Hurd, replacing GNU Mach's in-kernel device drivers. (This has been possible before, too, but involved several manual steps.) At the time of writing, our DDE port supports several network cards, while for other driver types we will need to add further generic infrastructure. Also, Arch Hurd had a booth at FrOSCon and released a new Arch Hurd LiveCD, so new users can easily test the current state of the Arch flavor of the Hurd.

Richard Braun contributed additional GNU Hurd instances: a Debian buildd, a Debian porterbox, and a public Hurd box. Especially the last one is important for you: after requesting an account, you can use it to test the Hurd without any own setup.

Samuel Thibault sent a new Bits from the Debian GNU/Hurd porters to keep the Debian folks up to date with our progres. And it is quite good: thanks to the relentless work of our porters, you can now use 70 % of all Debian packages with the Hurd, so we're getting closer to the goal of finishing a Release Canditate in time for Debian Wheezy. If you can, for example, port Debian packages and want to help the Hurd, this is the perfect time to get in contact and port your favorite missing package to the Hurd.

A different kind of status update was delivered by Samuel Thibault on the GNU Hacker Meeting (GHM) in Paris. We hope you enjoy watching the video of the presentation by Samuel Thibault: GNU/Hurd, aka. Extensibility from the Ground (slides, video). He nicely explains how the simple yet powerful concept of a translator gives power to a system's less-priviledged users (that is, without root access), without any security implications, and how subhurds and neighborhurds compare to Linux containers. It's all about freedom 0.

On the technical side, Thomas Schwinge improved the technical documentation of the I/O path when translators are involved, to make it easier for new developers to understand how all the different system components interact. Amongst others, Guillem Jover, Fridolín Pokorný and Jonathan Neuschäfer sent many patches for GNU Mach, improving stability, fixing memory leaks and generally cleaning up the code.

Maksym Planeta finished a project he has been doing as a university task: replace GNU Mach's old zone memory allocator with a new slab allocator written by Richard Braun, who also mentored Maksym during the project. This allocator, apart from being overally cleaner than the zone allocator, is meant to waste less memory than the zone allocator (less fragmentation and more memory can be reclaimed by the VM system), there are debugging/inspection features, and it's SPM-ready, thus readily usable once we get up-do-date SMP support in GNU Mach. It is now being tested and integrated.

And last but definitely not least, Jérémie Koenig finished his Google Summer of Code project to improve Java support on GNU Hurd. All in all, he also improved the Hurd signalling code, ported OpenJDK and began designing and creating a library for Java bindings for Mach and Hurd which already allows writing a Hello World translator in Java. It is still pretty low-level, but it paves the way for extending the core of the Hurd with Java, which is one of the benefits of the Hurd's distributed multi-server architecture: different components of the operating system can be written in different programming languages; not just C, but also C++, Common Lisp, and now Java -- and more to come.

So if you want to help getting the Debian GNU/Hurd Release Candidate done, or want to dig deep into DDE to have more device drivers running as user-space processes, please get in contact -- and maybe already grab the source code.

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More detailed.

GNU Mach is the microkernel upon which a GNU Hurd system is based. It provides an Inter Process Communication (IPC) mechanism that the Hurd uses to define interfaces for implementing in a distributed multi-server fashion the services a traditional operating system kernel provides. More detailed.

After our last Quarter of the Hurd, Q2 of 2011 has been picked up by a bunch of news sites, blogs, and so on, discussions and speculations have been running all over the net:

• Signs of life from GNU Hurd, LWN, Joe 'Zonker' Brockmeier, 2011-07-20;
• A Status Update On GNU Hurd: Java, Debian, Money, Phoronix, Michael Larabel, 2011-07-13;
• Coming Up: Benchmarks Of GNU Hurd, Phoronix, Michael Larabel, 2011-07-15;
• Debian 7 kommt offiziell mit Hurd als Kernel [de], Golem.de, Sebastian Grüner, 2011-07-14;
• Hurd Progresses - Debian GNU/Hurd by end of 2012?, The H Open, Dj Walker-Morgan, 2011-07-14;
• Debian 7 might come in a GNU Hurd version, Innocent Hacker, Amit Khajuria, 2011-07-17;
• Debian 7.0 Wheezy: Erste Pläne für Hurd statt Linux-Kernel [de], Netzwelt, Markus Franz, 2011-07-15;
• GNU Hurd Quarterly Status Report, OS News, Thom Holwerda, 2011-07-13;
• GNU Hurd will offiziell in nächste Debian-Version [de], Pro-Linux, Hans-Joachim Baader, 2011-07-13;
• Debian now has concrete plans to bring GNU Hurd to the larger community. It is expected to be released with the release of Debian 7.0 Wheezy towards the end of 2012 or beginning of 2013, reddit, mepper, 2011-07-14;
• RMS may finally shout "It's alive!" at GNU+HURD thanks to Debian, reddit, TheSilentNumber, 2011-07-28;
• Watch Out Linux, GNU Hurd Coming, Slashdot, timothy, 2011-07-14;
• and a lot more.

We are happy to see that there is considerable interest in the Hurd; but we also saw some misunderstandings, false rumors, and outdated information floating around. Thus we will try to clarify the situation regarding some of the more common misunderstandings.

• Debian GNU/Hurd strives to become an official Debian port: The Debian GNU/Hurd team is working hard to prepare a technology preview/release candidate for the next Debian release (Wheezy), to eventually become an official port alongside GNU/Linux and GNU/kFreeBSD -- but we don't know yet whether we will make it. This is also the understanding of (for example) Debian's spokesperson About Debian, The Hurd and Linux or in short: Yes, we will still have a Linux kernel, Alexander "Tolimar" Reichle-Schmehl, 2011-07-15. There is still substantial work necessary to indeed become a release candidate. If you want to help, please see our contributing page and the to do list maintained on http://wiki.debian.org/Debian_GNU/Hurd. We'd be happy to have you on board!

• Java support for GNU Hurd is nearby: Jérémie Koenig is working on making a versatile Java programming environment available on GNU/Hurd as part of his Google Summer of Code project, focusing on OpenJDK 7. Experimental packages are already available. Also, Java support in GCC (via GCJ/ECJ) has been available before, which Jérémie also improved.

• GNU Hurd supports X.Org, though a bit unstable: X support has been present for ages (anyone remember 1998's XFree86?), and X.Org also has been supported for a long time (for example, GNU Hurd support is explicitly mentioned in the X.Org 7.2 release announcement). It is true though that many modern graphic card drivers don't work anymore, as they require DRM (Direct Rendering Manager) support, so often only VESA is available. Also, X on the Hurd is somewhat unstable.

• GNU Hurd has weaker device driver support than the Linux kernel: Most of the drivers we use today were imported from Linux 2.0 series. For network cards, Linux 2.6.29 drivers are available through DDE -- however, this is not fully integrated yet, so using these drivers needs manual setup for now (guide). Support for other driver types is also possible with DDE in principle, but it requires some not-trivial work for each additional class of drivers, so this can take some time to become available. (An additional benefit provided by DDE is that the device drivers run as regular user-space processes -- unlike the old drivers we were using so far, which are part of the underlying GNU Mach microkernel.)

• The Hurd has SMP, but needs support for new chipsets: Both GNU Mach (the microkernel used by the Hurd), and the Hurd servers themselves come with SMP support. However, GNU Mach misses drivers for modern SMP chipsets, and there are also some SMP-related bugs in the implementation, so further work is needed for the Hurd to take advantage of multicore processors.

• Installation can still be challenging: Please take notice of the README file -- just like with any software in development, there are some known pitfalls to avoid. (Or better yet, help to fix.) Alternatively, you can simply use the the preinstalled image in QEMU/KVM/VirtualBox/...

• GNU Hurd is not the same as GNU/Hurd: The GNU project set out in 1983 to create a complete free operating system. When a distribution such as Debian combines their GNU-based userland with the GNU kernel (named GNU Hurd), the result is more or less a full GNU system. However, such third-party distributions are distinct from what an official complete GNU system release would be; and thus we often call them GNU/Hurd for clarity, similar to GNU/Linux or GNU/kFreeBSD.

• Performance: The benchmarks conducted by Phoronix (as reported by Test Driving GNU Hurd, With Benchmarks Against Linux, Phoronix, Michael Larabel, 2011-07-18) (Phoronix/Michael: thanks for doing these!) attest very good performance to the Hurd. Keep in mind though that these benchmarks were almost completely CPU-bound, so they essentially just confirm that we don't do anything stupid regarding CPU initialization (cache setup, etc.). The results would be different for benchmarks that actually exercise the operating system functionality more. The fact that the tests were performed in a virtualized environment, might also have helped the results, for example by mitigating the effects of our unoptimized I/O paths -- which are currently the major bottleneck in most situations. Nevertheless, these results are a hint that the extra IPC required in microkernel systems doesn't necessarily hamper performance quite as much as often believed. We are glad to see such solid benchmarks help dispel some of the myths around the Hurd and other microkernel-based systems.

• Given the available manpower, the progress is very good: Over the past decade, there were seldom more than half a dozen developers at any given time hacking on the Hurd, in their spare time -- not hundreds of paid developers like Linux has nowadays. Considering this, the progress made is quite encouraging with the system being pretty usable for many day-to-day tasks now. It is generally understood that the ambitious architecture of the Hurd requires a lot of effort to get it working at all, but the recent progress shows that once the foundations are in place, the Hurd design indeed allows the developers to be very productive. To see the progress over the last few years, you can have a look at our news archive. If you're interested, you can find various ways of contributing. We'd be happy to see you join in, because for the Hurd, every single helping hand makes a big difference!

Jérémie Koenig started working on his Google Summer of Code project: bringing not only Java to the Hurd, but also fixing or adding missing parts in the Hurd's components along the way. For example, he already contributed a set of signal handling improvements.

Samuel Thibault created the first Debian GNU/Hurd CD set with a graphical installer. You can dowload it at the usual place for Debian CD images.

Amongst others, Samuel also tracked down and fixed a port leak in file_reparent. This one got visible on the Debian package builder machine.

On the organizational side, there is now a real plan to release a Hurd variant of Debian with their next major release, Wheezy. Expected towards the end of 2012 or beginning of 2013, the Hurd-specific bits of that release effort's process are being tracked on http://wiki.debian.org/Debian_GNU/Hurd. There is still a lot of work left to be done, but -- as everyone knows -- a real goal as well as a bit of pressure might help to actually get it done. If you want to lend a helping hand in order to make this happen, porting packages is a great way to get started and do something useful at the same time.

Tanguy le Carrour offered to sponsor some Hurd work, and followed up on his offer by adding to the Hurd bounties that Thomas Schwinge had set up over at on FOSS Factory -- claim them if you can! It's not (not yet?) comparable to a Google Summer of Code student's salary, but a step into the right direction. So, if you have more money than time and want the Hurd to advance, why don't you join Tanguy?

At the end of August, Hurd folks will be meeting at the GNU Hackers Meeting in Paris. Samuel Thibault will be giving a talk (GNU/Hurd, aka. Extensibility from the Ground), and -- amongs others -- Jérémie Koenig will be there too, ready to answer all the questions about his Java/Hurd Google Summer of Code work.

As its principal idea, FOSS Factory, means to serve as a hub and organizational platform for connecting Free/Open Source Software developers with monetary sponsors. From http://www.fossfactory.org/aboutus.php:

FOSS Factory's mission is to accelerate the advancement of free/open source software by helping people collaborate on the design, funding, and development of innovative software ideas. All software solutions produced using our system are released under free/open source licenses. Our unique model brings the best of innovators from both the entrepreneurial and FOSS worlds together to solve real world problems using the mass resources of the FOSS community.

In very general words, their modus operandi is that the community (including the monetary sponsors) works together with the developers on splitting up tasks into suitable and assessable sub-projects as necessary, and then act as the reviewing instance, deciding on such sub-projects' success (and payment, successively). For more details see their System Overview.

For now, we can assume that the amount of money to be made by working on a GNU Hurd task in this framework is likely to be a symbolic amount only, rather than being representative for the real effort that needs to be invested. Software development is expensive, mostly due to the amount of time that is needed for completing any non-trivial task. Instead, these bounties should be regarded as an attraction/reward, perhaps also simply as a motivation for a developer to focus on one specific problem, and bringing it to completion.

Working on a task and/or suggesting/donating for a new task.

In principle, any Hurd-related development task is applicable (for example, from the GSoC project ideas, or from the open issues list), but it is of course recommendable to match sponsors' ideas with those of the developers and maintainers. For this, if you want to sponsor a project, but don't know which one to choose, or if you want to work on a bounty that is not yet listed on the site, we suggest that you talk to us first, either publically on the bug-hurd mailing list or privately on hurd-maintainers@gnu.org, if you prefer.

Both for supporting (donating) as well as claiming a bounty, you have to register at their site, and proceed from there. Please don't hesitate to ask Thomas Schwinge if you need help.

Continue to explore the list of open bounties.

This new installment is in no way meant to depreciate the developers' current, un-paid, efforts. It is also not meant to replace the volunteer work in the long term. Neither is it meant to trick the general FSF fund raising out of a few dollars. Instead, this is simply an additional means, a place for donators to give money for Hurd-specific tasks.

Everyone of the existing crew is eligible to do coding under this bounty system, but we also hope to attract new developers -- in a sense similar to our many years of participation in the Google Summer of Code.

Participation in/use of FOSS Factory's services has explicitly been set up personally by me, Thomas Schwinge; there is no inherent connection to the GNU Hurd maintainers. This also means that each contribution that comes to life out of FOSS Factory's framework is subject to the same rules/review process as any other contribution has always been.

Unless willing to discuss these publically, any concerns, questions, requests regarding this system can always be addressed directly to me.

We're again participating in the Google Summer of Code's 2011 edition. If you know someone who knows that her neighbor would be interested in getting mentored (by us) and paid (by Google) for working on a GNU/Hurd task, please hurry up: the student application period will end this Friday, 2011-04-08.

There's further progress to be reported on the package porting front: additionally to the usual suspects, Svante Signell has actively started with contributing by fixing or porting his favorite packages to GNU/Hurd. Welcome, Svante!

Amongst other fixes, Diego Nieto Cid submitted his work for using XKB's keymaps for the Hurd console. Of course, he was not the only one to contribute fixes; there's always our bunch of folks who appear every other month, or week, and send in some contribution. Also, as we ask our GSoC applicants to submit patches in order to substantiate their application, we've seen some additional ones due to that. (And you can, too.)

The Arch Hurd folks published their Year of Arch Hurd report, wrapping up their progress, including GHAMP (GNU/Hurd, Apache, MySQL, and PHP), X.org, and their Arch Hurd LiveCD. We had published our YotH 2010, too.

Finally we got a nice recognition (or did they mean...) by xkcd, How to Write Good Code, subtitled You can either hang out in the Android Loop or the HURD loop. Go figure!

Originally published in GNU Status Reports: January 2011.

From Olaf Buddenhagen, Arne Babenhauserheide, Thomas Schwinge: Yeah, that's quite right: the GNU Hurd project is still alive!

According to our mission statement, the goal is creating a general-purpose kernel suitable for the GNU operating system, which is viable for everyday use, and gives users and programs as much control over their computing environment as possible. It has a unique multi-server microkernel-based architecture---bringing advanced operating system research to the mainstream. More concretely, it's a collection of user-space server processes that run on the GNU Mach microkernel.

The Hurd doesn't fully deliver on the everyday usability goal yet, but it is seeing continuous improvement---and 2010 has been no exception. Let's take a look at the progress throughout the year.

• Apart from having done a lot of other work, Samuel Thibault, our Jack of all trades, merged his development branch that added Xen domU support to GNU Mach, which makes it possible to run a GNU/Hurd system as a Xen guest. Development of this started in 2007, and since then it has been heavily tested by using it for the Debian GNU/Hurd build servers, most of our public GNU/Hurd systems, http://www.gnu.org/software/hurd/public_hurd_boxen.html, and the Hurd project's wiki web server.

• We had Zheng Da work on a new hardware device driver framework, which is based on the Dresden L4 (Fiasco) group's DDE project, and allows running modern Linux kernel drivers as user-space server processes. Many network cards already work perfectly with this new framework. (It has not yet been integrated into the mainstream Hurd code base, so it needs to be compiled and set up by hand.) Other driver classes, such as hard disk controllers, will require further work.

• As in the previous years, we again participated in the Google Summer of Code 2010. Olaf Buddenhagen is our main guy for organizing this.

  Jérémie Koenig ported the modern Debian Installer to Debian GNU/Hurd. Installation images using the new installer are replacing the previous CD images, which were using an installer based on the old Debian boot floppies (and running under the Linux kernel)---Philip Charles has been maintaining these single-handedly for almost ten years! The new installer images are available from https://cdimage.debian.org/cdimage/ports/stable/hurd-i386.

  Emilio Pozuelo Monfort was investigating specific compatibility problems exposed by the extensive test suites coming with some software packages. Emilio's analysis uncovered a number of programming errors in the Hurd code, and he fixed several of them. As these typically affected other programs too, this improved stability and compatibility in general.

• Jérémie Koenig created a new implementation of a procfs translator, which is considerably more robust and efficient than the previous one. Tools such as top can now be used without problems.

  Some other translators (gopherfs, netio, tarfs) which have been created by external contributors in the past have been fixed up by Manuel Menal, and packaged in Debian. Thus, some of the results of Hurd's extensible architecture are now easier to access, and these updated translators can serve as examples for other developers to implement their own ideas.

• In addition to various general stability, compatibility, and portability fixes, several people (Samuel Thibault, Pino Toscano, Emilio Pozuelo Monfort, and others) have been working on fixing issues with specific Debian packages. So far, about 68% of all Debian packages are also available for Debian GNU/Hurd.

• Michael Walker started the Arch Hurd distribution, and together with other enthusiastic Arch developers (Allan McRae, Matthias Lanzinger, Alexander Preisinger, Stephen Gilles, Diego Nieto Cid) they got it working in an amazingly short amount of time, both as an installable system, and a live CD. So now there is a choice between two well-featured distributions for the Hurd. These new people of course also help forwarding Hurd development in general---Diego in particular contributed various patches to the Hurd console and other components.

• Carl Fredrik Hammar finished and presented his thesis, Generalizing mobility for the Hurd, http://lists.gnu.org/archive/html/bug-hurd/2010-01/msg00078.html, and passed with distinction.

This is a very short digest of what happened in the last year. You can read our regular Month of the Hurd at http://www.gnu.org/software/hurd/news.html, or by subscribing to our RSS feed at http://www.gnu.org/software/hurd/index.rss.

If you are interested, for example, in doing a university project on a multi-server microkernel-based operating system, or if you are interested in contributing to Hurd development in general, please see http://www.gnu.org/software/hurd/contributing.html. Or just talk to us at bug-hurd@gnu.org or the #hurd IRC channel on freenode.

French article by Manuel Menal, Gnu : L'année 2010 du Hurd.

Samuel Thibault updated the Debian GNU/Hurd installer ISO, and also again did his regular batch of bug fixing.

Arch Hurd is back in action!, too: they uploaded a first version of a graphical live CD.

Neal Walfield reported on the state of his Viengoos kernel / research project, which unfortunately is currently on hold, due to other commitments.

Olaf Buddenhagen raised an interesting use case: you can use a subhurd for debugging the main Hurd system. That is virtualization at its best!

Right before the end of the year, Diego Martin Nieto Cid sent a patch series to fix some issues with make dist.

Happy New Year 2011, everyone!

That's a short one. Apart from the regular business of having internal design / development / etc. discussions, and helping people to get their Hurd systems running, we had Diego Nieto Cid post patches (1, 2) to correct two programming errors, which Samuel Thibault quickly reviewed and applied to the source repositories.

A bit of bug fixing has been going on:

Samuel Thibault taught GNU Mach that Intel Pentium 4 and Opteron-class CPUs are not just i386, but in fact a bit more advanced. Not only does this help GNU Mach to select optimized code paths, but this information is also propagated to the user space, and used for the uname command, for example.

Pino Toscano continued fixing bugs in the socket-related glibc code and Hurd's pfinet.

After finding out that our pread implementation does not conform to the POSIX standard in one aspect, Manuel Menal analyzed this, and posted a patch.

Alexey Kuznetsov privided IPv6 raw socket fixes for pfinet.

Michael Banck uploaded a new version of crosshurd to keep up with recent packaging and dependency changes.

Samuel Thibault uploaded gopherfs packages to the Debian repository. He also enabled IPv6 support for Debian Installer installations.

Thomas Schwinge:

It's been a really long-long time (hooray!), but now flubber's root file system is totally hosed, and thus needs to be re-installed. (I've been running apt dist-upgrade when the box apparently crashed.) Running e2fsck on it spew out over 50.000 lines of illegal and multiply-claimed block lists, before I terminated it, so no chance. I'll do this over the weekend. /home/ etc. are not affected, thanks to being on a separate partition.

As of two days later, the machine was re-installed.

Yes, we're a bit late this month. Arne Babenhauserheide, the guy who has started and has been drafting the Month of the Hurd ever since June 2009 (yes, that one and a half years already!), moves on to other duties -- his wife has given birth to our first Hurd developer offspring (as far as I know):

Last friday my son Leandro entered our cold and too bright but friendly world, [...]

We wish them good luck for their new parental duty!

The other guy, Thomas Schwinge, who has been editing and publishing the Month of the Hurd will take over -- at least temporarily (mind you, Arne).

But, we got some Hurd news, too.

Olaf Buddenhagen posted a patch that allows to obtain number of ports in proc and libps by means of adding a new RPC -- and subsequently held a discussion with Samuel Thibault who proposed that instead of adding such functionality on an ad hoc basis, a more generic solution could be found, too. In the end, they agreed that this functionality was useful enough, and the patch was committed.

It is important to spend time on designing proper interfaces (RPCs in this case), but on the other hand what we're doing now need not be set in stone forever, as Olaf explains:

Well, we already have a mechanism for making communication protocols in the Hurd extensible: it's called the RPC mechanism... Let's not try to invent another generic mechanism on top of RPCs.

If ten year down the road we indeed end up with half a dozen miscallaneous info queries, we can still replace them by a new RPC covering all of it...

Thomas Schwinge moved some packages (gopherfs, netio, tarfs) from hurdextras to the Hurd's incubator repository; these are now available as Debian GNU/Hurd packages. Manuel Menal also spent time on actually making tarfs and good ol' gopherfs usable.

Similar treatment has been applied to Jérémie Koenig's new procfs implementation; this one is now used in Debian GNU/Hurd.

Jérémie found some problems with signal delivery -- signals apparently are not delivered as expected. Roland McGrath, this hairy code's original author, provided some insight:

It's not that it's a bug, it's that the Hurd has never had POSIX-1996 multithreaded signal semantics. The Hurd implementation predates those specifications.

He continued to explain:

The Hurd signal semantics are well-defined today. They are not the POSIX-1996 semantics in the presence of multiple threads per process.

This explains for differences comparing to other recent Unixy systems, for example Linux. Neal Walfield, our libpthread's main author, states that he sees no convincing reason to not adopt POSIX/Linux signal semantics and abandon Hurd signal semantics. Jérémie went on to send a first patch. While already working in that area, Samuel Thibault applied some further fixes to our two threading libraries, and among others, he also sent a related glibc patch to fix signal-catching functions. And then, there is still the project about converting the Hurd's libraries and servers to using libpthread instead of Mach's cthreads (libthreads); likely such signalling system moderizations could be done alongside of that.

Manuel Menal fixed a bug that occurred when sending file descriptors with SCM_RIGHTS over PF_LOCAL sockets. He also identified this bug as the reason why the SSH daemon's privilege separation was not working on GNU/Hurd -- now this is fixed and you can use the default of UsePrivilegeSeparation yes.

Michael Banck has, based on user feedback, applied some changes to the crosshurd package, and uploaded a new version.

In other news, the Arch Hurd guys rightfully concluded that now that they're having a package available for almighty GNU Emacs, no further user-land packages need to be ported. If only everyone was using Emacs...

Last, and least, there are rumors about our colleagues over at the Duke Nukem Forever department getting serious again. We shall see.

Neal Walfield and Michael Bank have been doing presentations related to the GNU Hurd: from the GNU Hackers Meeting in the Hague you can watch the video of the presentation by Neal Walfield: GNU/Hurd: It's About Freedom (Or: Why you should care) where he details why we're still interested in working on the GNU Hurd, and there is another presentation (including video) by Michael Banck: Debian GNU/Hurd -- Past. Present. And Future? (slides) from DebConf10, including a very nice nod towards the main actors who are currently pushing the Hurd forward.

Jérémie Koenig wrapped up his Google Summer of Code project (Debian Installer) by posting his Hurd patches for installer/build as well as the patches used for hurd 20100802-1~jk7 to the debian-hurd mailing list. Most of them have been handled in the mean time, and we're still waiting for you to test his work by following his easy four-step instructions.

However, even though that this year's GSoC has come to an end, he didn't stop working: among other things, he has rewritten procfs and published his version just before the end of the month:

I have successfully tested it with most of the Linux procps utilities, as well as busybox and htop. It seems to be stable, not too slow, and it stays under 1.5M in resident size.

Testing it is as simple as this:

$ git clone git://git.savannah.gnu.org/hurd/procfs.git
$ cd procfs/
$ git checkout jkoenig/master
$ make
$ settrans -ca proc procfs --compatible
$ ls -l proc/

Thomas Schwinge added some more information to the web pages, notably a bunch of open issues reports, to have them registered in a generic place, and to facilitate coordination. If you're looking for a Hurd-related project to work on, go looking there! He also converted and merged some of the hurdextras CVS repositories into the hurd Git repositories and our incubator. All of this should make it easier for new contributors to join in.

The Arch Hurd guys have some news to share, too:

• They reported on their current status, as well as they released a new LiveCD image, and added a Planet Arch Hurd which aggregates the different Arch Hurd Blogs.

• The team packaged everything you need for the GHAMP solution stack.

• Their Diego Nieto Cid sent a patch series to bring console-driver-xkb up to date. This is a add-on to allow using X keymaps to configure the Hurd console for non-US keyboard layouts.

Finally, amongst other bug fixing and other development work by the usual suspects, we had a short review of what the current Hurd contributors still need to use a GNU/Hurd system for most of their day-to-day tasks. This may help to prioritize the development efforts.

Philip Charles, our 72 years old provider of Debian GNU/Hurd installation CDs has now resigned from that position. This has lead to a flood of public thank-you responses, and surely yet more of those have been sent privately. Phil, thanks again for providing the many installation images you've started producing nearly ten years ago! -- oh, the joy of (not) uploading CD-size images using a 56k modem... -- and that have been the first choice for many of us to get a Debian GNU/Hurd system installed.

On the other hand, there's no need to worry about these news: Jérémie Koenig got the Debian Installer for the Hurd into a basically working state; there is a simple four step installation guide. This brings us a big step forward towards easy installation of Debian GNU/Hurd and automated image creation. You can track Jérémie's progress on his user page.

Emilio Pozuelo Monfort also made progress with his Google Summer of Code work. For example, he posted a new iteration of his proposed changes to exec as well as he added support for sending file descriptors over Unix sockets. These patches add features and improve compatibility to other systems, and thus help to get more software packages to work as expected on GNU/Hurd systems.

Ludovic Courtès fixed make dist, which allows for easy tarball creation of the GNU Hurd sources.

We've been in the news last month -- and this month yet again: LWN posted a well-researched article on the status of the Hurd: Koen Vervloesem: The Hurd: GNU's quest for the perfect kernel.

A bunch of patches have hit the mailing lists and source code repositories:

Jérémie Koenig posted a preliminary patch to add initrd (initial ramdisk) support in GNU Mach for his Google Summer of Code 2010 project: Debian Installer. With this patch, and some other patches that are still in flux, he ended up being able to install a Debian GNU/Hurd system using the Debian Installer -- which is the goal of his project. Patches being in flux means that there's still work left to be done to properly solve some issues, so there's no need to worry that Jérémie wouldn't have any work left until the GSoC ends.

Karim Allah Amed came up with the first patch for porting the clustered paging-in code from OSF Mach to GNU Mach, which should improve the virtual memory performance of the Hurd.

Emilio Pozuelo Monfort got a bug in glibc fixed, which unblocks a problem we've seen in coreutils' ln, and also continued to make progress on other grounds.

Zheng Da began to commit patches to make his DDE project support block device drivers, apart from fixing some other issues, too.

Samuel Thibault fixed memory leaks in pfinet, which is the Hurd's TCP/IP networking unit. Even though that a crashed pfinet server will be restarted upon its next use, having it eat up all system memory is to be avoided, of course -- and is corrected with these patches.

Carl Fredrik Hammar submitted patches to improve the stability of the auth server (rendezvous port death / invalid rendezvous ports).

Lastly, if you haven't seen it already: Richard Hillesley has posted an article GNU HURD: Altered visions and lost promise that caused quite a bunch of discussion -- some of it valid and constructive criticism, some of it less so. If you want to come in contact with us GNU Hurd developers, there are numerous options to contact us!

Zheng Da reported on the state of his ongoing work of porting DDE linux26 to the Hurd, which is meant to improve the GNU/Hurd hardware support. The devices as emulated by QEMU and VMware already work fine, but he's still seeking help for testing on real hardware.

Sergio López published patches as well as readily-usable packages to prevent thread storms in ext2fs when synchronizing large pagers. This should improve system performance and stability.

Emilio Pozuelo Monfort and Sergio López developed further patches (for example: exec, tmpfs) to fix or improve the various internal Hurd servers, and discussed them with other Hurd developers.

Justus Winter created a live CD with an installation wizard in the spirit of the OpenBSD installer. He needs testers to help improve it.

Ludovic Courtès informed that he has added support for cross-building packages from GNU/Linux to GNU/Hurd to the Nix package manager, as well as doing continuous cross-building of the GNU Hurd itself, and glibc.

The regular IRC meetings for Google Summer of Code students, their mentors, and any other interested parties are continuing on Mondays and Thursdays, 10:30 UTC, as Olaf Buddenhagen reported. If you want to catch up, have a look at the #hurd channel logs.

As always in the Month of the Hurd, these news blurbs are only a selection of what happened in the last month. There's always more to be found on our mailing lists, especially bug-hurd.

The Arch Hurd folks keep making good progress: their count of available packages keeps increasing, and one of their team reported the first instance of Arch Hurd running on real hardware (and uploaded a photo as evidence).

Of course, our Debian port is still progressing, too: 66% of all Debian packages are currently available for Debian GNU/Hurd.

Samuel Thibault's fix got included in libxcb1, so X.org again works out of the box using a simple startx.

Philip Charles extended his offerings with an updated GRUB USB stick for booting Debian GNU/Hurd.

Carl Fredrik Hammar proposed a patch to faciliate debugging the startup of misbehaving translators.

Mainly thanks to Jose Luis Alarcon Sanchez, we now have a new QEMU image. It can be run with a simple qemu -m 512 -hda debian-hurd-17042010-qemu.img.

Thomas Schwinge updated our glibc maintenance repository to a recent version, including a bunch of the patches from the Debian glibc package (and these are meant to eventually be submitted upstream). After a long break, he as well updated his toolchain cross-compilation script cross-gnu to the current source code packages, and added C++ support.

On to the Google Summer of Code 2010: we got three students working on the Hurd this year:

• Jérémie Koenig, mentored by Samuel Thibault, will be working on adapting the Debian Installer to produce working Debian GNU/Hurd installation images so we can easily offer up to date disc-sets. (Details.)

• Emilio Pozuelo Monfort, mentored by Carl Fredrik Hammar (who was a GSoC student in 2007), will be working on a task that may be perceived as less exciting from the outside, but yet is extremely valuable: fixing compatibility problems exposed by projects' testsuites. (Details.) For starters, he already got a glibc patch accepted upstream.

• Karim Allah Ahmed, mentored by Sergio López, will be working on tuning the VM Subsystem in GNU/Hurd to bring the virtual memory management in Hurd/Mach up to date. (Details.)

We'd be happy to see YOU sign up on our mailing lists (bug-hurd and debian-hurd are the main lists), and contribute towards making the Hurd usable for everyone, as written down in our mission statement. Perhaps one of the unassigned projects (outside of the Google Summer of Code context) from our project ideas list is fit for you?

This month saw bugs dying as they met hackers like Jérémie, Samuel, or Zheng, Thomas, or Jakub (keeping it to a few ones which were discussed on the bug-hurd mailing list).

Olaf, Thomas and Fredrik wrote and submitted our organization application for the Google Summer of Code 2010. However, Google is asking most GNU projects to work under the GNU project umbrella, so we aren't listed as an organization on our own, but instead will again participate as a subproject of GNU.

Anyway, this organizational detail is not at all important for interested students; you can apply for any of the ideas that are listed on our project ideas page (or come up with your own ideas, of course!) via the GNU project GSoC page. If you apply, please also include the information we're asking for on our student application form. Don't hesitate to contact us beforehand, if there are any questions. We're looking forward to seeing your applications, please send them in before 2010-04-09!

A bit late, but here it is finally: the MotH for February, 2010.

This month saw the first running and testable DDE driver by Zheng Da, with which he begins to reap the benefits of porting DDE to the Hurd -- essentially, allowing us to use current Linux device drivers.

Samuel Thibault pushed a libpciaccess x86 backend to X.Org:

This adds support on x86 for OSes that do not have a PCI interface, tinkering with I/O ports, and makes use of it on GNU/Hurd.

In the course of this, he also got commit access to X.org, so it should be easier now to get further Hurd-related patches applied.

As announced in our previous news blurb, at FOSDEM, Bas did his presentation of Iris, a new capability-based microkernel OS in the Embedded Developer Room, and Olaf illustrated Why is Anyone Still Working on the GNU Hurd?, and presented his work of Porting KGI graphics drivers from Linux to GNU Hurd, in the Alt-OS Developer Room.

In Mikel Olasagasti's words:

The room was full and people was "standing-up" for the talk. Some people even couldn't enter to the room (+20?).

Antrik [Olaf] made a good job. Was nice for the crowd to see Hurd running X, slow but working.

The regular IRC meeting schedule has been changed to Wednesdays, 11:00 UTC; see the IRC page for details.

Last, but not least, it is time again to think about the Google Summer of Code. In 2007, the GNU Hurd had one successful project, in 2008 five of them, 2009 saw another one, so we obviously plan to make it five projects again this year. We already have dozens of ideas online, and will add yet more -- also based on YOUR suggestions and wishes!

So, if you're a student, and interested in working on the GNU Hurd, please join in; browse through the GSoC pages, and don't be shy to contact us!

This month, we saw the first booting version of an Arch Hurd system, which seconds the Debian GNU/Hurd distribution that already provides two third of the Debian software archive compiled for GNU/Hurd.

Nine Hurd developers will meet at FOSDEM 2010 on February 6th and 7th in Bruxelles, Belgium. On Sunday, Olaf will be giving two presentations in the Alt-OS Developer Room: Why is Anyone Still Working on the GNU Hurd? (10:30), and Porting KGI graphics drivers from Linux to GNU Hurd (13:00). The day before, on Saturday, Bas will be giving a talk about Iris, his new kernel (18:00, Embedded Developer Room).

Carl Fredrik Hammar finished and presented his thesis Generalizing mobility for the Hurd and passed with distinction. Congratulations! Its abstract reads:

The GNU Hurd features mobile objects in its implementation of filesystem backing stores. This thesis investigates the limitations and security concerns these objects present, and how they can be overcome. This is done in preparation for new applications that feature mobile code and mobile objects. In addition, one such application is studied and implemented, in which mobile code is used to make the ioctl system call more extensible.

So, when are YOU going to do a thesis, or another project on a GNU/Hurd-related topic? Contact us if you are interested!

This month Samuel Thibault merged his development branch into GNU Mach's master branch -- meaning that his GNU Mach Xen domU port is now part of the official sources. Only the microkernel (GNU Mach) needed to be extended, and no changes were needed in the Hurd, or glibc code bases. He had started this port in 2007 already, but it has been in heavy use over the last two years already, so merging it into the main source bases was long overdue.

He also got the necessary Xen patches committed into Xen's unstable branch, so that from Xen's 4.0 release on you'll be able to boot GNU/Hurd systems using pv-grub, without the need to prepare a special bootstrap image (like an initrd).

Of course, running GNU/Hurd systems in other virtualization environments is possible too, but the Xen domU approach offers superior performance compared to QEMU's machine emulation, for example.

Samuel also spent some time on adding code for detecting invalid (duplicate) port deallocations, and started fixing these, as well as he fulfilled his usual share of miscellaneous bug fixing.

The DDE port of Zheng Da now passes the first tests, bringing us the first steps towards updated device drivers -- and much lower overhead for maintaining them.

Now that the Debian GNU/Hurd build stats are again hosted on the master Debian build machine, Debian developers see their packages' build failures more prominently, and quite a few started to fix their packages.

Thus, thanks to the porting work of mainly Emilio Pozuelo Monfort and Pino Toscano, users of the Hurd can get many more packages directly via the Debian GNU/Hurd distribution. Thanks to their and the other porters' relentless work, the percentage of available Debian packages has reached 66%, rising. For a specific example, they ported many GNOME packages, so that the gnome-core metapackage is installable again. Please test these and report back.

Thomas Schwinge started the planning for a GNU Hurd folks meeting at FOSDEM on February 6th/7th 2010 at the Université Libre de Bruxelles.

Guillem Jover jumped in and started fixing GNU Mach build warnings -- meaning that Thomas Schwinge's evil plan finally worked out, when he enabled -Wall in an October 2006 commit:

+# Yes, this makes the eyes hurt.  But perhaps someone will finally take care of
+# all that scruffy Mach code...  Also see <http://savannah.gnu.org/task/?5726>.
+AM_CFLAGS += \
+       -Wall

---

The GNU Hurd team wishes a pleasant Year 2010 to everyone!

This month Zheng Da, our former Google Summer of Code student working on network virtualization and some related topics, published the code for the pcnet32 device driver that he had modified to run as a user-space process instead of inside the kernel, and posted some preliminary performance benchmark results. The test results are mostly on par with the in-kernel driver, so they show that moving the lower-layer parts of the networking stack, the device drivers themselves, into user space can be done without losing (much) performance. Given this encouraging start, work is going on to explore whether the Device Driver Environment that has been created for L4-based systems can be used for providing GNU/Hurd systems with device drivers that (a) are more recent than our current ones, (b) support classes of devices that we don't support so far, and (c) are running as (possibly separate, fault-isolated) user-space processes.

Thanks to Samuel Thibault, the latest Debian GRUB 2 package (1.97+20091130-1) supports native installation from GNU/Hurd itself -- booting GNU/Hurd systems with GRUB has always been working, but until now it wasn't possible to install GRUB from a GNU/Hurd system. GNU GRUB has originally been written for booting GNU/Hurd systems, so this step completes its original purpose.

Samuel also continued to work on preparing the Xen branch of GNU Mach for being merged with the mainline code, and he fixed a kernel panic in the kernel's floating point support code.

This month Philip Charles created a new installation CD, the L series, for the Hurd, which brings us a big step towards installing the Hurd from the Hurd (without the need of a Linux-based installer). If you enjoy testing stuff, please give it a try.

On the same front, Michael Banck uploaded a new version of crosshurd that makes it again possible to use this package for creating a GNU/Hurd system image directly from Debian unstable packages.

Also, Thomas Schwinge migrated Sergiu Ivanov's nsmux, Flávio Cruz' cl-hurd (clisp bindings), and Carl Fredrik Hammar libchannel repositories into our new incubator Git repository, making them easier to access for other contributors.

Our bunch of porters continued to make further Debian packages usable on GNU/Hurd: Pino Toscano worked on a lot of packages, and Wesley W. Terpstra made mlton build -- together with Samuel Thibault, who first had to enhance GNU Mach to support allocating more than 1 GiB of RAM to one user-space process, which mlton needs.

On the go, Samuel also fixed a number of other bugs here and there, for example together with Eric Blake and Roland McGrath hashed out a difficile issue in the filesystem servers regarding POSIX conformance and system stability.

This month saw the successful completion of the Google Summer of Code 2009, for which Sergiu Ivanov created a unionmount translator. His work allows you to simply union one directory or translator into another one, so you see the files of both of them side by side.

He was mentored by Olaf Buddenhagen and both are now working on polishing the code and extending the namespace based translator selection (nsmux) which allows you to read a node with a selected translator by simply appending ,,<translator> to its name.

That aside, we saw the usual steady rate of enhancement discussions, as well as bugs getting fixed: X server crashing, preventing that GCC versions after 4.2 optimize too much, etc.

Samuel Thibault uploaded a new version of the hurd Debian package which improves system stability by fixing a long-standing bug in the exec server that had randomly made it hang, inhibiting the creation of new processes.

Sergiu Ivanov implemented most of the functionality of the union mount translator which allows combining the filesystem trees exported by several translators with the filesystem tree of the underlying node (in contrast to a pure unionfs, which won't do that). The patches are currently undergoing testing and review on the bug-hurd mailing list. This work is being done as a Google Summer of Code project, and we're happy to tell that Sergiu successfully passed the project's midterm evaluation.

Also, Zheng Da fixed a bug in GNU Mach's BPF (Berkeley Packet Filter) implementation and contributed a number of fixes and improvements for rpctrace which should help further debugging.

Aside from looking for new contributors all the time, here is another job opening that doesn't require specific Hurd knowledge: we're seeking someone interested in writing a regression test suite for Hurd components.

This month Thomas Schwinge finished migrating the main Hurd, GNU Mach, MIG, libpthread and unionfs to Git. You can find the new repositories at https://git.savannah.gnu.org/cgit/hurd/.

Also, he made libpthread buildable stand-alone by separating its build system from the Hurd's.

Additionally, Olaf Buddenhagen wrote a usability report about his experience with the GNU Hurd for everyday work.

General-purpose operating systems not only fail to provide adaptive applications the information they need to intelligently adapt, but also schedule resources in such a way that were applications to aggressively adapt, resources would be inappropriately scheduled. The problem is that these systems use demand as the primary indicator of utility, which is a poor indicator of utility for adaptive applications.

We present a resource management framework appropriate for traditional as well as adaptive applications. The primary difference from current schedulers is the use of stakeholder preferences in addition to demand. We also show how to revoke memory, compute the amount of memory available to each principal, and account shared memory. Finally, we introduce a prototype system, Viengoos, and present some benchmarks that demonstrate that it can efficiently support multiple aggressively adaptive applications simultaneously.