It's called Io and yes - it's one of the most extensible languages I encountered. Its main mechanism for extension resembles PicoLisp and fexprs - any method can decide whether it wants its arguments evaluated or not. Coupled with homoiconicity it allows for arbitrary code transformations on runtime - and that's even before taking multiple, prototype-based inheritance and arbitrary stack traversing into account.
I wrote a PyParsing port in Io, for my text-based game I'm writing in Io. It was a very interesting and unique experience - normally, when porting things, you just go over the code and translate all of it line-by-line from one language to the other. With Io, however, it was trivial to extend Io with (most) features that Python code required and in effect the code and the language met in the middle. After adding certain things to the language most of the "porting" was done with a set of basic regexes.
Now, the problem is Io is dead, is not being developed, and that's tragic. The implementation is pretty straightforward, however the documentation is severely lacking and the years without development left it far behind most other languages.
I think it's a real shame and I was thinking about investing some time into Io development myself, but my game project halted earlier this year diminishing my motivation, not to mention I'm not sure if I would be up to the task.
Still, I'd be more than happy to help if someone would like to contribute to the Io development. I would like to see Io resurrection and I think the language still has a lot to offer even to the modern programmers.
 https://github.com/piotrklibert/ioparsing - see src/syntax.io, list literals, dict (map) literals and string interpolation is implemented there.
 There's one problem I wasn't able to solve (yet), which is that the left arg of the assignment operators are always evaluated - so no destructuring assignment unfortunately. This is hardcoded in the VM, I even found where, but ultimately didn't find the time to fix this.
impressive little language
I forgot to mention, Io also supports Lua-like coroutines. It's an incredibly powerful language, mixing Smalltalk, Self and some Lisp in a non-image-based, easy to use package, accessible to "normal programmers". I would really, really like to see it developed again... and used, even if just a bit. I guess I'm repeating myself here, so I'll stop.
were you involved in its development or just a loving user ?
The latter... To be honest, I thought about contributing - Steve Dekorte, the author, stopped developing the language, but is relatively responsive on GitHub and merges PRs - but I had to stop that side-project just before doing any real work on VM side. I wanted to add destructuring to the language and wanted it to work with operators so that, given suitable definitions of , ... and <- this:
[a,b,...,z] <- aLongList
I don't have the time for it right now (edit: and anyway, there's a limit to how much a single person can do), though, so the only thing I can do is to advocate the language and encourage its use. Which I'm trying to do right now :-) I also have a blog post on Io waiting to be published, I'll post it once I resolve the issues with my blog's domain.
IO language is a language that is similarly easy to extend. You might call it a language prototyping language in the sense that it's easy to test out language features (or whole new languages) in IO.