Ray Tracer : 6 points

Objective: Write a program to process an input file format (participant designed) which describes a scene of objects, rasterizing it and placing it in a readable output image format.

Reasonable Expectation: The program should provide input for camera positions, lights, materials with shading and texturing capabilities, and will at least provide basic support for spheres and planes. The input mechanism should be minimally documented, so that a technical user can understand the input method and provide scene information.

Above and beyond: Provide support for general polygons, additional lighting models/options, multipass operations for additional detail. Parallelize the algorithm to provide additional speedup, provide a mechanism to distribute over multiple machines, and optimize and tune the individual operations of the ray algorithm (point these out in code with references).
Network Abstracton Layer : 2 points

Create a network interface layer which provides a file - rather than the traditional berkeley socket - interaction system for connection oriented network communication. The file abstraction system should be visible in the file system (read up on unix named sockets) and should provide the ability to do socket programming simply via text operations on files. For more information on the presentation of such an interface, please see the plan9 paper: The Organization of Networks in Plan 9 http://cm.bell-labs.com/sys/doc/net.html

Reasonable Expectation: The file interface layer should provide the ability to create a new connection, bind that connection to a port, listen on that connection for client requests, and send and receive data via simple file reads/writes.

Above and beyond: Provide full documentation for interfacing with this system, write test programs to stress functionality as well as bandwidth capabilities, and use the system on multiple machines to provide well known existing services (web, mail, news, etc...) to demonstrate its completeness.
Massively Multiuser Dungeon (MUD) : 4 points

Objective: This project is the implementation of a MUD game. You must create a server that is the MUD itself. You may also create a client interface to connect to the game, or you may use telnet as your client program. The requirements of the game is that there be a set of rules in place for users to interact with the environment, other users in the system, as well as NPCs (simulated by the server). You may not use any MUD already available (diku, smog, swr, etc.etc.) as the base of yours. It must be all new code.

Reasonable Expectation: People will be able to log into the game via telnet or your own client. Once in the game they will be able to interact with other people, and move about the world. When creating a character they can pick from a list of races and classes each with special perks and flaws.

Above and Beyond: Create a working AI NPC that will interact with the user with given commands, or actions. Players can get new skills or abilities from gaining experience points. And NPC's in given areas when killed will give experience based upon the players level.
Web Scraping Library : 3 points

Create an api for scouring web output and present it in a reasonable fashion to a consuming system. This system should be able to cope with abstract interfaces described by the client application for handling web-originated structures. Provide ability to define modular structures to build up complex handling mechanisms, as well as a way to talk programmatically with new apparently interactive-heavy interfaces which use ajax. This system should not simply be limited to textual output, but should provide numerical, image, sound and video scraping and even reprocessing based thereupon.

Reasonable Expectation: Users can describe web output formats and the data they wish to scrape from this system, either as single elements or iterable contained items (e.g. lists/table entries), and identify these scraping modules uniquely and encapsulate them in other scraping modules to form complex interpretation blocks.

Above and beyond: Provide a stateful interface for working with web systems which expect interactivity (forms, paging outputs) that can be easily programmed for and modularized. Add onto this with the ability to deal with client side scripting, most notably javascript, and recognize ajax patterns and request mechanisms to provide access to the newest web systems being developed.
VFS Filebrowser : 6 points

Objective: Create a file browser which provides seamless file/directory representations for as many file configurations as possible. This should include easily understood representations - compressed or archived files should act as directories which can display their contents as files, and some more interesting examples - executables or library files could contain a list of the individual object files or even the symbols they define as individual files, xml/html files could present their tags/sections as navigable hierarchies, and so on. This system should not just provide read-only interfaces to these systems, but writeable interfaces as well.

Reasonable Expectations: Create an application which shows files in a 'current' directory and allows you to navigate either higher or lower in a hierarchical tree either with the existing file system, or through any number of layers of file abstraction interfaces. Detail at least 5 separate file types supported by the browser, and these should be able to be viewed nested recursively.

Above and beyond: Provide write access at any depth of abstraction. Allow dynamic mounting of different hierarchies at any point in the vfs tree. Include more complex systems like relational database connections, network services (web/mail/dns/news), or any other distaff data source which could be viewed in a traditional hierarchical file system view.
Object Set Domain Specific Language : 7 points

Objective: Design and Implement a language to acquire or update information from/to an aggregate set or sets of data through an object-oriented set of interfaces. Provide critical tools for manipulating the full suite of OO capabilities largely ignored in the traditional data set interaction languages like dialects of SQL: not just has_a or the n x n relationships, but also inheritance, polymorphism, and generics (templates). Create a simple backend interface which allows for persistent storage of data, and create sample usages of the system, highlighting the specific features of the language itself.

Reasonable Expectation: an interpreted language in which one can define a single set with associated data members, relationships between sets in n x n correlatives, relationships between sets in hierarchical correlatives, polymorphic behavior as a result of data contained within a set, and the capacity for storing generic data and specializing behavior based on the actual type of data stored.

Above and beyond: Provide a full specification for the language devised to accomplish this goal. Allow users of your language to provide long term storage in the form of a structured file layout/filesystem/rdbms.