I made a toy language called Cowbel to experiment with various language minimalism features:
http://cowlark.com/cowbel/example.html
It's an attempt to take as many features as possible out of a language and still have an expressive Javascript-like language. It worked pretty well, but of course, actually producing the compiler is the easiest part of any new programming language.
Features include:
- all types are anonymous (although interfaces are named)
- aggressive type inference which allows the compiler to distinguish between scalars, direct objects and indirect objects (via a vtable) at compile time --- not only does it do direct function calls if it knows what type an object is, but you don't have the scalar/object schizophrenia that Java and C++ does; integers are just objects implementing the int interface, but there's no object overhead
- very limited compiler knowledge of the language semantics --- int semantics like addition, subtraction etc are defined in the standard library
- template-based generics, full closures, nested functions
- multiple return values
- objects, methods (but no classes)
- non-nullable
- compiles into C for maximum interoperability
It was going to have prototypical inheritance via composition, where an object could inherit methods from an arbitrary number of other objects, but I never got round to implementing that bit.
One of the bits I'm most proud of is that I managed to unify block scopes and object constructors. {...} constructs an object. The only difference between one used as a block and one used as a constructor is whether you assign the result to anything --- the compiler just optimises everything away is you don't! This makes nested functions and methods identical, and drastically simplifies the language semantics...
if (condition) { thisIsABlock(); }
var object = { thisIsAnObject(); }
It's not actually useful, mind. There are too many rough edges and the compiler tends to crash if you give it invalid code. But it was really interesting to do.