Handel-C is a high-level programming language which targets low-level hardware, most commonly used in the programming of FPGAs. It is a rich subset of C, with non-standard extensions to control hardware instantiation with an emphasis on parallelism. Handel-C is to hardware design what the first high-level programming languages were to programming CPUs. Unlike many other design languages that target a specific architecture Handel-C can be compiled to a number of design languages and then synthesised to the corresponding hardware. This frees developers to concentrate on the programming task at hand rather than the idiosyncrasies of a specific design language and architecture. Additional features The subset of C includes all common C language features necessary to describe complex algorithms. Like many embedded C compilers, floating point data types were omitted. Floating point arithmetic is supported through external libraries that are very efficient. Parallel programs In order to facilitate a way to describe parallel behavior some of the CSP keywords are used, along with the general file structure of Occam. For example: par { ++c; a = d + e; b = d + e; } Channels Channels provide a mechanism for message passing between parallel threads. Channels can be defined as asynchronous or synchronous (with or without an inferred storage element respectively). A thread writing to a synchronous channel will be immediately blocked until the corresponding listening thread is ready to receive the message. Likewise the receiving thread will block on a read statement until the sending thread executes the next send. Thus they may be used as a means of synchronizing threads. par { chan int a; // declare a synchronous channel int x; // begin sending thread seq (i = 0; i < 10; i++) { a ! i; // send the values 0 to 9 sequentially into the channel } // begin receiving thread seq (j = 0; j < 10; j++) { a ? x; // perform a sequence of 10 reads from the channel into variable x delay; // introduce a delay of 1 clock cycle between successive reads // this has the effect of blocking the sending thread between writes } } Asynchronous channels provide a specified amount of storage for data passing through them in the form of a FIFO. Whilst this FIFO neither full nor empty, both sending and receiving threads may proceed without being blocked. However, when the FIFO is empty, the