Window Manager

Objective: Your team will write a fully functional X11 window manager, which should meet the following basic specifications for window manipulation.

Windows can be resized
Windows can be closed
Windows can be rearranged

The following features are suggestions for somewhat more full featured window managers.

The window manager can control the root desktop's apperance, with either images, patterns, or colors (or any combination)
Windows can be overlapped and have a sense of depth.
Some provision is made for launching applications, either with keystrokes or with a mouse initiated menu.
Non-user window movement can take place (cascading, tiling, etc.).
Multiple Virtual Desktops can be created.

Recommendations: Look at simple window manager implementations (mwm, twm) and more complex ones (blackbox, windowmaker) for ideas regarding window control and simple actions. This objective is much less an intensive coding exercise than a chance to really show off the Energy Theme in the competition.
Substance Intake Monitor

Objective: Your team will create a program which can calculate the approximate content levels of the human bloodstream, based on user-inputted factors of weight, types of intake, and effect on the system. It should provide a percentage for a particular content, and list symptoms associated with that degree of intake. The effects will logically be different for caffiene and water.

Recommendations: This project can be done either with or without a GUI, and as a result, the goal is not necessarily to provide a particularly eye-catching interface. A wide breadth of substances and symptoms with good user control over the information used to make a decision regarding the output should be the goal of this program. A good system might ask for all the ingredients in a drink, be able to classify the drink to be later referenced, and either have resident or search online repositories for the effects of particular amounts of the ingredients in the system.
Checkers

Objective: Your team will write a checkers program that runs as either a single-player vs. computer game, or networked with another instance of the program. It must implement all the rules of checkers (http://www.jimloy.com/checkers/rules2.htm) and provide a non-random computer user to play in single-player mode.

Recommendations: Separate this project into 4 separate tasks.

The game representation. Choose a mechanism for user-interaction/game representation and stick with it.
The board system itself, including the piece positions and rule constraints.
The networked component. Devise and implement an API for communication of game information.
The computer user. This can be the most challenging portion of this project. Ideally, it should be able to choose the best movement based on a forward thinking system some moves (iterations) deep into the game from the current position.
Redtris

Objective: Your team will write a Tetris-style game that roughly follows the rules of the classic game. You can also choose to include the multiple derivations of tetris that have been devised (square, sticky, cascade), or include a story to go along with the game itself. You can also add multiplayer support, most likely through the network. This project must have, at the end, at least a single player game with speed changes due to levels, and some visual representation with user interaction.

Recommendations: This project can be done either using a GUI or not. A terminal (perhaps ncurses) based puzzle game is not a ridiculous proposition. The additional rules can be implemented easily if the behavior of pieces in the system is written extensibly. The networked addition is a more laborous task, but should not alter the rules of the game (most are last player that survives wins)
Massively Multiuser Dungeon

Objective: This project is the implementation of a server/client pair for a multiuser dungeon environment. The nature of the environment are up to the teams, but the requirements for the project are that they have a rule set in place for users to interact with the environment, other users in the system, as well as NPCs (simulated by the server).

Recommendations: This project can be complex or simple depending on the goals of your team, but the basic implementation should follow these rules

Clients can request information about their current position (it is up to the server to decide what they see)
Clients can request information about their current user (the server retains the users vital statistics, and can transmit messages to users no matter where they are)
Clients request actions, and are required to poll the server for position and user information to keep their client in synch with the server.
Image Processing

Objective: Write a basic inferential image processing system. The program should be able to look at an image and recognize basic shapes, outlining them, and retaining them in a vector form. Simple implementations will be able to determine shapes and letters. More complex implementations can look at a photograph and infer light sources, relative positions based on shadows, and shapes of non-uniform objects in a scene. This objective must be able to recognize the following basic geometric shapes in a pre-generated scene as a minimum.

Circle
Square
Triangle

Recommendations: Start small with this objective. Define a system of input and output for raster to vector conversions, and slowly add features with their corresponding algorithms. Many image and pattern recognition algorithms are documented online at http://www.umiacs.umd.edu/research/EXPAR/papers/slap.html. The math for this objective may seem daunting at first, but the implementation to every algorithm makes the project easier as you go along.
Language and Interpreter/Compiler

Objective: Design a language based on the Energy theme, and implement an interpreter/compiler for it. Once the design of the language is laid out, the judges will review the language to see if it meets requirements (unlike the other objectives, these requirements are not easily quantifiable). Once the design is approved by the judges, you will implement either an interpreter or a compiler for it. The interpreter/compiler must take the original language and either interpret it into a form processable by another program (a shell, bc, another compiler), or compile machine code for the host platform/architecture.

Recommendations: For implementing your language design, use the lexical and grammatical parsers, lex and yacc. They can simplify your implementation immensely, and will provide a basis for starting your interpreter/compiler. See their manpages for more information.
Ray-tracer

Objective: Write a ray tracing system that generates images from input sources using ray tracing algorithms. Define an input scheme, as well as choosing a mechanim for displaying the ray-traced image. The system must be able to have the following basic primitives defined in the system, as well as implementing a camera position, and (of course) at least a single light source.

Cube
Pyramid
Sphere

Recommendations: Look online for simple to complex ray-tracing algorithms. http://www.ece.eps.hw.ac.uk/~dml/cgonline/hyper00/raytrace/rayalg.html is one particular site. Implement algorithms alongside test cases for input primitives, and don't make any one system too complex. In the end, the system itself should simply compound environmental effects upon the tracing algorithm itself.