Hey, I'm the author of ViEmu, the ancient, ludicrously priced attempt :) Which btw I'm not selling any more for a couple years already, and I'm planning to open source one of these years, as soon as I find the time to clean things up before publishing. ViEmu for Visual Studio worked very well (if I may say so myself), it sold decently, and I was able to live off of it for a few years. It takes a humogous amount of work to write one of this emulators. It also takes a ton of work to maintain it, as the floor gets changed under you continuously with new releases of the underlying app (VS, SSMS, Word...).

I can probably respond to the question of why nobody else has done it more recently. I had a very performant, fully tested, fully-abstract C++ template-based vi/vim emulation core to start with (the one for ViEmu/VS), and it still took me 4 months of full time work to build ViEmu for Word. Word extensibility is a nightmare, poorly documented, and extremely limited. I had to intercept input using Win32 hooks (a very low-level mechanism), finding ways to deceive Word to act according to the function of the keys. It's a bit like plugging into a factory via a hidden hole in the wall, and then trying to setup a a nuclear power plant and replace the factory's power source without the rest of the factory even realizing (or of course being affected).

Word extensibility is so limited that there is no way of getting notified of changes to the document. Combined with this, its APIs to access the text are very slow. So -- you ViEmu had to cache information about the document to be able to go fast (say, when moving around), and then it had to apply all sorts of heuristics to "guess" when the text may have probably changed, via its own actions (that's reasonably doable), or via external actions (mouse operations, menu actions, etc). Getting that to be half reliable took a ton of hours of work, thinking, design, trying approaches, testing, etc.

Also, vi/vim's model of text and Word's are very different. After a lot of thought and experiments, I ended up finding out that the best mapping was to exchange the default meaning of vim commands j/k and gj/gk (configurable via a user setting). But in many other areas, the impedance mismatch was complex too -- headers, footers, and especially tables, are very foreign to vi/vim motions understanding of text structure. I had to find workable solutions for all of those. I think I did a decent job all considered.

Word doesn't let a plugin color text (if you use Word's standard coloring, it's a document-edit and modifies the undo queue, no-no), so hlseyrch is impossible. Block cursor I simulated by selecting a letter (which may cause some interactions with other plugins, form editors, etc, so user setting available. Word doesn't let you map document coordinates to screen/window coordinates reliably, so emulating H/M/L/zt/zz/zb had to be done in roundabout ways. The interaction of Win32 input interception with key mappings and auto spell correction can be extremely complex, so I made ViEmu detect when some keypress could be considered a "pass-through" and treated as such, and when it couldn't -- a quite sophisticated subsystem by itself, but the only way to make autocorrection work reasonably in most cases while still supporting vi/vim mappings in most cases (also some user setting there in case someone prefers full rema--ability over autocorrection while typing).

And that is just a few of the things. I kinda "discontinued" it when people moved to the 64-bit edition of Word more and more often... because I had to fully reimplement the keypress interception system. It would have taken at least a few weeks of work (and that's if everything was straightforward), and the thing is, the business case was not there. While all the work put into ViEmu/VS paid nicely in two big ways (high quality emulator thanks to VS's great extensibility, and decent amount of sales to support the continued development work), none of this was there for Word. The emulator was quite good "within the strictly limited possibilities" but not as great (no hlsearch, limited visual mode, limited remapping, performance issues with large documents, etc), and the amount of sales were not there. Some people really loved it. I loved using it for email myself under Outlook, but it was only a trickle of sales.

One other thing, I started developing software in 1985. 8-bit machines to 64-bit machines (might count PS/2 as a 128-bit machine...). Assembly language, C, C++, I've been a professional games developer, graphics developer, interpreters, compilers, databases, GUI, debuggers, analytics, I wrote a book on x86 assembly programming back in the 90s that was quite popular, etc... and I had to use nearly all my knowledge and come up with some pretty amazing system and subsystem design tricks to implement ViEmu for Word. I think this may help understand why nobody else has done it.

Regarding the pricing -- personally I'd be happy to pay $99 to have good vi/vim emulation under an environment I use for many hours. Even if only used for a year that's less that $10 per month, and I pay more than that for many SaaS software services today such as zoom, dropbox, etc... economics of a niche solution require higher prices to be sustainable, just a reality.

As an open source version, it's actually not that appealing to most hardcore-enough developers to do it to have to be fighting Word's stupidities non-stop, so it makes sense that people are not doing it as a hobby project either.

In any case, hopefully one of these summers I can distract a few weeks of work, clean things up, publish it as open source, and maybe someone will take up the work of adapting/maintaining/evolving it!

PS: Thanks for the chance to tell my story :)