Clemens integrated the module system and the functionally sound I/O facilities into SAC. Later on he worked on the implicit support for multithreaded execution of SAC programs on shared memory architectures. Clemens is particularly interested in all aspects of parallel program execution, in compiler optimization techniques, and in memory management.

Sven-Bodo made the basic language design of SAC. He is particularly interested in compiler optimizations, compilation to multiprocessor systems, as well as language re-design due to application feedback. Currently, he works on a re-design of the type system of SAC as well as language extensions for unifying arrays and streams.

Bob investigates to what extent array properties such as shape relations can be exploited for code optimization. He implements his concepts as part of the optimizations integrated into the SaC compiler. In addition, Bob also works on porting the backend of his APEX APL compiler from Sisal to SAC.

Artem has done his PhD on data-layouts for improved vectorisation. He is currently working on type-driven streaming in SaC.

Stuart is looking into dynamic adaptation of resource usage for parallel executions.

Carl is doing a PhD on automatically compiling SAC programs for the MicroGrid architecture developed at the University of Amsterdam.

Hans is looking into streaming computations through multiple accelerators including GPUs and FPGAs.

Job is working on a package manager for SaC that ensures correct cross-module builds in the context of versioning, name duplicates and cross-platform reproducability.

Niek implements a new improved code generator for CUDA. It allows mapping with-loop index sets into thread-spaces by means of a few well-defined combinators. These mappings can either be user-specified in the form of pragmas which can be inferred by means of a few alternative strategies through the compiler as well.

Reg implements support for structures, arrays of structures, and structures of structures, as long as they are not recursively nested.

Alexei provides CFD applications for SaC.

Bernhard provides case studies from vision and single processing applications.

Volkmar has led the development of an eclipse plugin for SaC. He also has leveraged SaC's code portability for heterogeneous multi-core platforms in vision applications.

Daniel is the chief designer and engineer of the Unibench benchmarking platform and is involved with application benchmarking.

Stephan has integrated the axis control notation into the SAC compiler. The axis control notation allows for extremely concise and elegant specifications whenever the effect of certain array operations is to be restricted to given axes of argument arrays. As part of his Diploma thesis, he worked on an improved module system which covers support for dynamic linking, the new type system and one day even runtime code optimisation.

Max has implemented a resilience scheme for CUDA codes.

Working on his term project, Kai has implemented with-loop scalarization, an important optimization schemes which prevents the actual creation of temporary arrays during the execution of nested with-loops. In his Diploma thesis, he implemented a completely redesigned memory management system based on reference counting. By introducing new intermediate languages for memory management instructions, a variety of optimizations became possible in this area. He did a PhD on applying concepts from dependent types to array programming for advanced optimization and correctness analysis.

Jing did a PhD on automatically compiling SAC programs for the NVIDIA CUDA GPGPU architecture.

Dietmar implemented the compiler backend for generating efficiently executable code from multi-generator with-loops. Later on he worked on extending the compiler backend to support arrays whose shapes are statically unknown.

Jan-Henrik worked on improving the internal compiler infrastructure. As a part of his term project, he designed a conformity checker for the syntax tree representation that can be derived mostly automatically from a formal XML specification.

Markus integrated the array padding optimization into the SAC compiler as part of a term project. Markus graduated from the University of Kiel with a Diploma in Computer Engineering in 2002.

Visiting from the Tunesian National Institute of Applied Sciences and Technology (INSAT), Sonia wrote her Diploma thesis in Lübeck. She implemented the NAS benchmark CG (conjugate gradient) in SAC and evaluated the performance of her implementation with respect to the reference implementations.

Gijs has developed an optimisation for doing fold-operations in-place that operate on hyper-planes of higher-dimensional arrays.

Working on his term project, Borg implemented and evaluated various loop scheduling techniques for the multithreaded execution of SAC programs. Borg graduated from the University of Kiel with a Diploma in Computer Engineering in 2002.

Helge implemented the cache simulation tool for SAC as part of a term project. Helge graduated from the University of Kiel with a Diploma in Computer Science in 2002.

Andreas worked together with Florian on the first SAC-home.org presentation of the SAC project.

Working on his Diploma thesis, Karsten implemented with-loop fusion techniques that overcome the traditional limitation of with-loops to generate exactly one result. Karsten extends internal multi-generator with-loops to multi-operator/ multi-generator with-loops.

In his Diploma thesis, Steffen investigated advanced compilation techniques for shared memory parallelization, namely a hybrid execution model that combines elements of traditional fork-join and single-program-multiple-data approaches.

Abhishek implemented the BLAS routines in SaC.

Hraban integrated records into SAC doing his Bachelor thesis in the project.

Nico developed an interface that allows for calling SAC functions from within C programs, as part of a term project. In his Diploma thesis he re-implemented several standard optimization techniques based on an internal program representation based on static single assignment form. Nico graduated from the University of Kiel with a Diploma in Computer Engineering in 2001.

Florian worked together with Andreas on the first SAC-home.org presentation of the SAC project.

Daoen implemented a variant of with-loop folding that does not require all loop boundaries to be known at compile-time. His work contributes to improve SAC performance in the absence of statically available shape information.

Björn investigated the effect of loop tiling/loop blocking on the performance of SAC programs and developed a tailor-made tile size inference strategy as part of his Diploma thesis. Björn graduated from the University of Kiel with a Diploma in Computer Engineering in 2001.

As part of his Diploma thesis, Jan-Hendrik developed and implemented optimizations in order to decrease the organizational overhead in the multi-threaded execution of SAC programs. Jan-Hendrik graduated from the University of Kiel with a Diploma in Computer Science in 2000.

Sören implemented with-loop-folding for arrays of statically known shape as major part of his Diploma thesis. Sören graduated from the University of Kiel with a Diploma in Computer Science in 1998.

Arne integrated most of the high-level optimizations into the SAC2C compiler as part of his Diploma thesis. Arne graduated from the University of Kiel with a Diploma in Computer Science in 1996.

Michael has worked on implementing some basic though still missing compiler optimizations, namely exploitating of associativity, commutativity and distributivity in conjunction with constant folding. His more recent term project covered type information upgrades and the introduction of semi-static function dispatch facilities.

Henning worked on the basic compiler from SAC to C (SAC2C) as part of his Diploma thesis. Henning graduated from the University of Kiel with a Diploma in Computer Science in 1996.