I made some simple benchmark scripts so see how many processes I can spin up on my laptop with elixir and got 262,084 before the Erlang VM shut it down. I wrote a similar script in JS and it got up to 11,000 before crashing. This is of course just a personal experience and may be inaccurate.
I also did a simple operations in one minute script for both and elixir got 3,858,545 operations while JS got 5,845,228.
Actor library of some sort: yes; supervision tree like Erlang: simply not possible. Really, not possible–shared mutable state stands in the way.
That’s merely a default, which can be overridden by a command-line argument, so the actual limit is more like 132,000,000 
Why not possible? Check for example https://akka.io/ You isolate state in actor and only pass messages / events.
What is really hard achieve in other languages is true process isolation , one process breaks can take down all virtual machine. But if you got into cloud you can achieve this is some other way like using some orchestration for example Kubernetes which will restart pod if some failure.
I’m familiar with Akka. You can imitate Erlang-style supervision without the BEAM and the enforcement of non-sharing, you cannot replicate it. With Akka the “message” you pass often contains a reference to a mutable object which is an immediate “game over” for Erlang-style supervision & recovery. Granted, that’s considered an anti-pattern to do that, but it can be done, so as with any other potential bug, it will creep into large production systems. (Even more fun, in the case that you do that, you have to implement locking around access to such an object… One of the great joys of concurrent programming in the Erlang style is NO LOCKS.) This leads to advice like"Don’t use actors for concurrency. Instead, use actors for state and use futures for concurrency"" and questions like this (ugh!)
Also with Akka, you’re just using the regular process threads for scheduling, so an actor ties up its “scheduler” (again: ugh!) until it’s done processing the receipt of a message. Also with Akka, if you have even one point in your code where you accidentally call a regular Java IO routine instead of the special event-driven ones, the you have the possibility of blocking a scheduler–and although there are event-driven libraries for network & file I/O, guess what’s a blocking design intended to use a thread-per-call? JDBC! There are ways to mitigate this, but now you’re configuring ForkJoinPool’s and ExecutionContext’s (ugh! ugh!)
All of that is what happens when you attempt to implement the actor model on top of a runtime which was not designed with explicit support for it.
Kubernetes is not close to a substitute. It gives you something similar but only at a VASTLY coarser grain. Restarting a whole pod is no substitute for restarting a single Erlang process. Consider the common pattern of breaking out state into a process that does nothing but handle it, so that a failure of logic or processing does not lose state. Now consider both the network overhead of having those in separate pods, plus the overhead of configuring and maintaining the deployment–simply not practical to use this to replicate the fine-grained recovery you get with the BEAM. (Not to mention the 4-6 orders of magnitude increase in RAM of a Kubernetes pod as compared to an Erlang process.)
And, through the absence of any metaprogramming facilities when I looked last time, really bad at building abstractions. Which is something where Elixir shines. I see Golang as a useful systems level language and I’m watching Golang and Rust go at each other while I’m eating popcorn and coding my business-level applications in a language that makes sense for doing that.
Uh… no? It uses a GC, has no detailed memory control, etc… It would not be even remotely useful to build something like a system chip on or a kernel or so (compare to Rust or C or C++).
Even at the higher level Go takes more code than what is usual in languages while also being less safe (Interface{}'s Everywhere!).
I don’t think that Go lang can be called system level language as it has GC, where Rust can for sure can be called system level.