• Titanium Tutorial - a quick (but incomplete) introduction to Titanium
• Recent Titanium Tutorial - a complete tutorial on Titanium presented at PSC'04 (and another tutorial from IPDPS'03).
• Introduction to the Titanium Compiler - how to use the compiler (tcbuild) itself
• Language reference manual - the reference which describes the full syntax and semantics of the Titanium language
  • Current Version: PDF    PS
    
  • Archival Version (for citation): U.C. Berkeley Tech Report, UCB/EECS-2005-15, 2005. PDF
• Java 1.0 documentation - Titanium currently uses the Java 1.0 libraries
      Language Specification: HTML    PDF    PS   
      Library API Documentation: HTML   
  
• Java 2.0 documentation - Titanium is essentially a superset of Java 1.4
      Language Specification: HTML    PDF   
      Library API Documentation: HTML   
  

• Environment variables recognized by Titanium applications - to control the Titanium runtime layer
• Command-line options for tc - control the raw titanium-to-C compiler which gets called by the tcbuild wrapper
• udp-* backend usage - instructions on how to use the udp-* distributed backends
• mpi-* backend usage - instructions on how to use the mpi-* distributed backends
• gasnet_trace usage - instructions on how to profile communication on gasnet-* backends
• Using native code - instructions on how to call C from Titanium
• Name mangling scheme - grammer used for translating Titanium method signatures into unique C identifiers
• PRCS documentation - Titanium uses PRCS for source code control
• Boehm-Weiser GC - the garbage collector used by Titanium
• PAPI - Titanium provides a library interface to the PAPI performance introspection library in ti.lang.PAPICounter, allowing access to CPU hardware performance counters

Requirements: The U.C. Berkeley Titanium compiler, known as titaniumc, compiles Titanium programs into C. A C compiler is required to compile the generated code, and the compiler itself is written in C++. We recommend GNU gcc and g++, but any ANSI C/C++ compiler can be used. For parallel platforms, either pthreads or a messaging layer is required.

• Download current Titanium source release (tar-gz)
  NOTE: Public releases happen infrequently, but active development continues - please contact us if you'd like to try a more recent beta version.
  • Browse the archive
  • Release notes and version information
  • Installation instructions (generic) and specific platform notes
  • Licensing information
  • Contact a Titanium developer if you have questions or need assistance.
• Titanium for Microsoft Windows
• Older releases

The Titanium compiler is available on the Berkeley NOW and Clumps machines, and can easily be accessed from Solaris and Linux uniprocessors by mounting /project/cs/titanium/srs on your machine. Some additional hints on using Titanium in the Berkeley environment are included in the tcbuild introduction. To report bugs in the implementation, access the Titanium bug database (restricted to UC Berkeley on-campus access).

We manage installations of the Titanium compiler at the following locations (some of these may vary in the exact compiler version which is available). This is for informational purposes only - some of the systems listed are managed by institutions with no official affiliation with the Titanium project or UC Berkeley.

The Titanium debugger, sdb, is also available for many platforms. The source code is available, as is a User's Manual in html or gzipped postscript and an example Titanium program. See Carleton Miyamoto's sdb page for up-to-date information on sdb.

Because Titanium is compiled to C, users do not have full access to the AWT and certain other Java libraries directly from Titanium. However, a rudimentary interace to a separate Java process can be built using native methods. An example of Titanium code that communicates with a separate JVM process is available; it demonstrates graphical output for a naive particle simulation. Because of limitations on the underlying message layer, the this example current runs only on shared memory machines and uniprocessors.

The released version of Titanium runs on most uniprocessors and SMPs running either Solaris, Linux, IRIX, AIX, or Microsoft Windows. We also have distributed backends which support clusters of uniprocessors and clusters of SMPs (CLUMPS) with varying network interconnects, as well as a number of backends for various supercomputer architectures (e.g. Cray T3E, IBM SP2, etc.)

Both Solaris threads and Posix threads implementations exist, so ports to other operating systems that support Posix threads or something similar should be straightforward. The runtime system currently uses the Boehm-Weisser garbage collector on operating systems supported by that software (most major OS's) - other more exotic OS's not supported by the Boehm-Weisser collector (most notably Cray Unicos) run without garbage collection.

The output of the Titanium compiler is C code, although the tcbuild script that is normally used to invoke the Titanium compiler automatically calls the C compiler as well. This backend compiler is normally the Gnu C compiler (gcc), although others have been used. (The intention is to make the C output Ansi compliant so that any reasonable C compiler could be used as the backend.)

Distributed backends exist for a variety of cluster network layers, such as VIA, Solaris AM-Myrinet (Berkeley NOW project), LAPI (IBM SP2 and SPPower3 machines), standard UDP (the portable alternative) and MPI 1.1 (high-performance portable option). Efforts are underway to support other runtime layers. Please let the Titanium developers know if you are interested in porting Titanium to a new platform.