Future of D 2.x as stable/bug fix, and what's next for D 3.x

[Eljay]

What is left to do for D 2.x for it to be declared "done" and in 
stable/bugfix mode only?

I haven't seen a Vision/20xxHy for a while.

What features (and breaking changes) are on the horizon for when 
the next generation D 3.x begins?

There are plenty of languages out there that have intriguing 
features that may (or may not) be good candidates to consider for 
D 3.x.

Rust with its type state, which allow for a strong memory 
ownership model for a non-GC language.  Although I think it adds 
considerably to the learning curve struggle to grapple with, at 
least for Rust novices such as myself.

Swift and Kotlin, both of which have syntax similarities aimed at 
preventing certain common categories of bugs.

OCaml and family (e.g., F#, and I include Haskell as a kissing 
cousin of the ML family) that embrace functional-first functional 
programming.

C++17 and C++2a, as one of the frontrunner languages that's 
evolving in amazing ways (but sometimes odd ways), and its goal 
of backwards compatibility really has made for some awkward and 
awful syntax.  Take Spirit for example:  that's both 
awe-inspiring combined with an amazing abuse of operator 
overloading.

Both C# and Java have been evolving and adding new and 
interesting functionality.  Some just gloss and polish and sugar, 
but some language features are very interesting.

Then there's always Lisp and family.

Thoughts?  Plans?  Roadmap?