These are projects initiated of my own volition.
Note: I wrote this page in 2002, as I finishing my undergraduate degree. Since I haven't touched any of these projects in over five years, I maintain this page largely for historical interest: this is what I cared most about as an undergrad.
AHWM is an X11 window manager comprised of approximately 15000 lines of C. It interfaces directly with Xlib and incorporates the latest X11, KDE and GNOME standards for window managers. It supports every feature I have ever found useful in a window manager. It is quite stable - I run it 24/7 and I haven't found any serious bugs for a few months now. I've tested it on every flavour of Unix I could find, which includes the usual ones (Linux, *BSD, Solaris) and some more esoteric versions such as SunOS 4.1 and XFree86 under MacOS X. It is fully documented and the source code is publishable quality (eg, very few quick hacks, etc.). You can download this from: http://people.cs.uchicago.edu/~ahiorean/ahwm/
Update, February 2007: I used this as my window manager until about a year ago, when I switched to Metacity on those machines where I run an X11 desktop. I would like to update this code to comply with the latest Unix desktop standards, but until then Metacity does a fairly nice job for me, and I recommend Metacity over AHWM.
ALIX is the start of a OS kernel for the x86/IA-32 architecture. I haven't touched this code since perhaps 2001. At the stage where I left it, I was basically finished with the major parts that needed to be written in assembly (boot loader, initial 32-bit mode setup, enabling paging) and development went to C (I wrote a small utility which parsed out the code and data out of a Linux ELF executable and built a kernel image). As I remember it, I was working on the VGA driver and beginning to port over parts of the other kernel (from the yalnix project) when other projects caught my attention. I can get you the code for this if you wish, but it's probably in a nasty state. In addition, it may be difficult to duplicate my build evironment, so I can give you a floppy image if you want to actually boot it (it doesn't do anything useful yet).
Our printing system in the dormitories is based upon Berkely LPR, and win9x does not come with an LPR client. The University of Texas has an LPR client for windows, but newer versions have a disagreeable licensing policy. In response, I wrote a "network print provider" which is basically a system library for Windows that takes the output from the print drivers and sends it to a printer. This library worked acceptably under Windows NT (where I did most of the development), but it proved very difficult to port to Windows 95/98/ME, as these systems are not resilient to any types of errors and the print provider interface for win9x is not well documented by Microsoft (I spent a week deciphering hex dumps and assembler listings to figure out exactly how windows would call the provider library). I discontinued work on this project when we came to an agreement with the University of Texas about licensing their print provider for use in the dorms.
Below I list some of the more interesting or relevant projects I have completed as a student.
ALIX was written after I took a class on OSes. In this class, we worked in a simulated hardware environment and wrote a full kernel for semi-realistic hardware. I can get you these sources as well (4500 lines of C), but you will not be able to test them as the hardware simulator is unavailable. The simulator was based upon the one written for the OS classes at CMU, described at: http://www.andrew.cmu.edu/course/15-412/projects/proj3/proj3.html
In another of my classes, I wrote a compiler for a Pascal-like toy language. The language supported most of the features of Pascal, along with a few other "features" such as nested function scopes (functions defined within functions) and type inference akin to what ML does (both of which are non-trivial to implement). This project was written in about 3000 lines of python and it produced sparc assembly.
In another class, I wrote a source-level debugger for the Solaris/SPARC architecture (4000 lines of C). This debugger dealt with all of the low-level issues that a "real" debugger deals with, and could be turned into something comparable to gdb or dbx (after lots of user interface work). It supported dynamic loading of extension modules (all of the useful debugger features were written as modules, similar to how the apache web server works), examining and changing memory, controlling program execution, printing symbolic backtraces, examining the memory map and loaded libraries, and it would find program symbols either from the symbol table (available on all non-"stripped" programs and libraries) or from the debugging "stabs" section (which includes line numbers and is available with the compiler debug (-g) option). I could get you the code for this, but it only works on Solaris. If you would like, I can send you a transcript of some sessions with the debugger to demonstrate its features.
For an advanced OS class, I wrote a message-passing library, similar to MPI but without the remote execution features. This is meant to automate the process of writing parallel algorithms by including synchronization primitives, and synchronous and asynchronous message passing. Whereas MPI is meant for writing parellel programs that run on clusters of machines, this library implemented message-passing between programs running on a multi-processor server, but could be extended to work across a network. Information on MPI can be found at: http://www-unix.mcs.anl.gov/mpi/
My final project for a networking class was to write a web server. It featured CGI, HTTP authentication, and it could run in either a multi-threaded or multi-process mode. This was only about a day or two of work, but I could get you the code or run a demo if you'd like. I only mention it here because I've actually used this web server in my job as a systems administrator.
As I'm quite familiar with web programming in various languages, last year I TAed a class on web programming for our Masters program in CS. This included helping students with basic unix tasks (eg, cron jobs, using emacs or vi, etc.), apache administration, php, perl, python, sybase and HTML/Javascript. I also adapted a personal project (the beginnings of a book on learning/administrating unix, another work-in-progress) for this class; it is available at: http://people.cs.uchicago.edu/~ahiorean/cs552-unix.html
Update, February 2007: please don't take the linked document too seriously. I now find parts of that document very amusing.