A new version of the Sh language for GPU programming in C++ has been released. This version features a new backend infrastructure implementation allowing such things as running part of a stream application on the GPU and part on the CPU at the same time. Many other fixes as well as platform compatability enhancements were also added. (http://libsh.org)

The FxPlug API allows Mac OS X developers to write OpenGL based image processing plugins for Apple’s Motion video effects software. Designed to run on ARB_fragment_program capable hardware, it allows chains of complex effects to be run entirely on the GPU. With over 100 GPU filters and generators already running within Motion, this is well worth a look. (http://developer.apple.com/appleapplications/fxplugsdk.html)

Version 0.7.7 of the Sh GPU Metaprogramming Language is now released. Sh allows GPUs to be programmed directly using C++. This version features a back end for the OpenGL Shading Language, Mac OS X support, and major speed improvements for stream programs (the GPGPU subset of Sh). (http://libsh.org)

A free open-source library for grid-based, Navier-Stokes fluid simulation on the GPU has been released. The code compiles under the DirectX 9.0 SDK (Summer 2003 Update) and is structured for easy integration into existing DirectX applications (for example, single methods to add fluid emitters and to advance the simulation, etc). This code has been used in the computer game Ensign Expendable developed by Strange Bunny. (Open-Source Direct3D Fluid Simulation Library.)

Cg Release 1.3 Beta 2 has been released with support for the latest GeForce 6 Series (NV4X) GPUs. This version of Cg offers the following features and improvements:

• New vp40 profile, which enables texture sampling from within vertex programs
• New fp40 profile, which provides a robust branching model in fragment programs, and support for output to multiple draw buffers (“MRTs”)
• Support for writing more than one color output (i.e., MRTs) in the arbfp1 and ps_2* profiles
• New semantics to access OpenGL fixed-function state vectors from within ARB_vertex_program and ARB_fragment_program
• New “-fastprecision” option for arbfp*, fp30, and fp40 profiles, to use reduced precision storage (fp16) when appropriate
• Support for 16 profiles

(http://developer.nvidia.com/object/cg_toolkit.html)

At its World-Wide Developers Conference Apple introduced Core Image as a feature of its upcoming Tiger release. Core Image is a framework for image processing on the GPU using a modified stream processing paradigm. Core Image is an interesting computational framework for offloading some general-purpose computations on to the GPU. It appears to be the first commercial effort to offer a general image computing environment for GPUs. The library comes with 100 basic plugins, called “Image Units”, and can be extended by developers. The computing model is based on stream processing, where each kernel is expressed in a high-level language and computes a result image based on some number of input images. The kernels can be strung together in arbitrary image computation “graphs”, in a model similar to that described by Michael Shantzis in his 1994 paper A Model for Efficient and Flexible Image Computing. Registered Apple Developers (free registration) can access a pre-release version of Core Image.

In cooperation with the creators of BrookGPU, GPGPU.org has added discussion forums for beginner and general/advanced Brook topics. Brook users of all levels can use these forums to discuss questions, experiences, and other information with other Brook users and with the developers of BrookGPU.

This SIGGRAPH 2004 paper by Buck et al. presents Brook for GPUs, a system for general-purpose computation on programmable graphics hardware. Brook extends C to include simple data-parallel constructs, enabling the use of the GPU as a streaming coprocessor. The paper presents a compiler and runtime system that abstracts and virtualizes many aspects of graphics hardware. In addition, the paper provides analysis of the effectiveness of the GPU as a compute engine compared to the CPU, to determine when the GPU can outperform the CPU for a particular algorithm. The paper evaluates the system with five applications, the SAXPY and SGEMV BLAS operators, image segmentation, FFT, and ray tracing. For these applications, the Brook implementations perform comparably to hand-written GPU code and up to seven times faster than their CPU counterparts. (Brook for GPUs: Stream Computing on Graphics Hardware. Ian Buck, Tim Foley, Daniel Horn, Jeremy Sugerman, Kayvon Fatahalian, Mike Houston, and Pat Hanrahan. To appear at SIGGRAPH 2004.)

The Cg Toolkit allows developers to write and run shader programs using a wide variety of hardware platforms and graphics APIs. This release introduces several significant new features:

• Interfaces, a language construct that facilitates the creation of
  general, reconfigurable Cg programs
• Unsized arrays
• Parameter instances may be created and shared between multiple programs
• Parameters may be marked as compile-time constants, leading to more efficient compiled code
• Support for x86 Linux (Red Hat 7.1 or later etc) and Mac OS X Panther

Be sure to check out the CgReleaseNotes and CgManualAddendum in the documents package for full details. (NVIDIA Cg Toolkit 1.2)

Brook for GPUs is an active research project at the Stanford University Computer Graphics Lab to explore general-purpose computing on modern programmable graphics hardware. BrookGPU is a compiler and runtime implementation of the Brook stream programming language which provides an easy, C-like programming environment for today’s GPU. The beta version of Brook for GPUs is now available for download at the link below. Brook requires no graphics or GPU programming experience, and supports both ATI Radeon 9500+ and NVIDIA GeForce FX /Quadro FX hardware, using both DirectX and OpenGL APIs. BrookGPU has a complete fallback CPU implementation. (Brook for GPUs.)