The examples I'm surprised no one has mentioned so far: C and C++. (gcc is written in C. clang is written in C++. Just about every C or C++ compiler is written in C or C++ or both, though there are exceptions like the C compiler on the Symbolics Lisp machines.)

There is even a conference for languages like this:

Workshop on Self-sustaining Systems (S3)

http://www.hpi.uni-potsdam.de/swa/s3/

The Workshop on Self-sustaining Systems (S3) is a forum for discussion of topics relating to computer systems and languages that are able to bootstrap, implement, modify, and maintain themselves. One property of these systems is that their implementation is based on small but powerful abstractions; examples include (amongst others) Squeak/Smalltalk, COLA, Klein/Self, PyPy/Python, Rubinius/Ruby, and Lisp. Such systems are the engines of their own replacement, giving researchers and developers great power to experiment with, and explore future directions from within, their own small language kernels.

I was interested in Atomo-in-Atomo, because I'm working on CoffeeScript, a language that is written in itself:

http://jashkenas.github.com/coffee-script/documentation/docs...

Come on! by now everybody knows what you're working on! ;-)

Squeak, for example, has its VM quite literally written in a subset of itself called Slang, which translates to C: http://ftp.squeak.org/docs/OOPSLA.Squeak.html

Also, most Lisps (especially Scheme) have a relatively small core written in C for bootstrapping, and the rest of the language is written in itself.

The Jikes RVM (Research Virtual Machine) uses a similar approach: http://jikesrvm.org/ Most of the implementation is written in Java, but there's a small core written in C that bootstraps the VM.

GHC is written in Haskell (and is the premier Haskell compiler).

Both Ruby and Python have interpreters implemented in themselves.

http://rubini.us/

http://codespeak.net/pypy/dist/pypy/doc/

Aside from a tiny VM written in C++, nearly all of Factor (http://factorcode.org/), including its parser, optimizing compiler, and code generator, is written in itself. The author of Clay (http://tachyon.in/clay/) is working on a new version of its compiler written in itself too.

Delphi was, pre .net days.

It had a handful of assembler code to bootstrap it, and from there it built upon itself

I think I read the very first implementation of Pascal was in Pascal. Which of course meant it couldn't run at all! So it ran on the second Pascal implementation: a hand translation of the first to assembler.

The Scala compiler's written in Scala.