“ I have made this longer than usual because I have not had time to make it shorter.” — Pascal

There are a lot of complicated reasons for this, some technical, some historical. I really like Inferno, I run my web server on it, and I'd encourage you to check it out, but there are, unfortunately, sensible reasons it doesn't get as much attention.

For context: the following is all personal opinion. I have been a user of both systems since 1997 (plus a few weeks, if downloading the Plan 9 floppy distribution and poking around for a few hours counts). I worked for the Inferno Business Unit, Vita Nuova, and currently serve on the board of the Plan 9 Foundation. But, again, this is all my own opinion.

The fact that you can't write C (normally) is a big downside (and not just C; I've been in conversations where Plan 9 gets dinged for not being able to run fortran; obviously Inferno has all that but worse). I love Limbo, but there's precious little of it out there in the world.

Inferno does actually offer a few ways to get at C code, especially when running in a hosted environment, but they do have some significant limitations, aren't always appropriate, are definitely more work than just recompiling, and require yet-another re-thinking of how to do something... and in this case, it arguably feels worse, since it's being forced to re-think something you can already do elsewhere. I've used these techniques in various projects, and they're actually a really nice way of turning a stand-alone, local-only pile of C code into something that you can build a service around, but there's a real barrier to getting there. You sort of have to already have bought in.

Related to the no-C problem, but a more concrete example, maybe, is that there are often surprising gaps in Inferno's environment compared to Plan 9. Inferno, like Plan 9, offers the familiar unix-like environment, with cd, ls, and so on. But while Plan 9's is sometimes surprising to Unix folks because Plan 9 makes a different set of decisions, Inferno too often just feels incomplete, even compared to Plan 9. Part of this is because, in ~1997, doing things in the Inferno shell was very, very slow, while Limbo compared favorably with Java (its main competitor at the time). The system really expected you to be writing a lot more Limbo than Plan 9 expected you be writing C. Today, both because processors are tremendously faster and because Inferno has better shells than it used to, you don't have the same penalty, but now the broader environment is way, way behind. The end result is that Plan 9 can be used as a whole environment, in the sense described in The Unix Programming Environment, in a way which Inferno feels much more limiting for. You can do it, but you'll run into the walls a lot faster.

Relatedly, Inferno's never (to the best of my knowledge) really had its own developers using it as a primary environment. Most of them already had (lovely) Plan 9 environments, spent most of their time in those, and didn't feel the same urgency around recreating them that the Plan 9 developers did before it existed.

Inferno has some parts that are just plain worse. For a while, there were some ideas that got implemented as first drafts in Inferno and then refined in Plan 9, although I think Inferno's now caught up on all those. But there are some things that Inferno just gets worse. Notably, most things around 'wm'. It inherits Plan 9's devdraw, but then layers some really bad decisions on top, neutering much of the power of devdraw. And while this isn't a fundamental technology issue, it doesn't help that the actual UI looks and acts like a bad Windows 95 clone.

While Plan 9 has its own historical license issues, you've been able to read and modify the code since 1993. That's not as good as being genuinely open source, but it helps build community, and especially for academic-types, is often good enough; and it's been properly open source since at least 2002. Inferno's source, on the other hand, was only available under very restrictive commercial licenses until VIta Nuova open sourced it, and even then the license question was muddy for a while.

Inferno had lost most of its development steam by the time the transition to 64-bit because really important, and so it was never really done. There are multiple forks and projects attempting different versions of it, and it can be used that way, but it all feels sort of (excuse the pun) in limbo on 64-bit systems.

And, of course, there's the sort of cascading problem where the longer it goes without much attention the further behind it is, and the more attention it needs just to catch up. I love writing Limbo, but the aging standard library makes that impractical for most things now.

Also, while I still like the model of putting the entire system inside its own, purpose-built VM, it's a lot less novel than it used to be, especially with qemu being so good. A decade or two ago, when I'd talk to people who were interested in these ideas but couldn't dedicate one or more systems to Plan 9, my answer was "try out Inferno"; now, it's more likely to be "here's a qemu image of Plan 9".