A question I've been wondering about recently is why aren't programming languages more... modular? Like, why isn't there a system for using X interpreter/compiler with Y syntax? Every language is bound to a specific runtime environment and syntax, but would it be possible to mix and match these somehow?

Well theres LLVM and WASM which is kind of like that

this question is partially inspired by seeing that, interestingly, Python and JavaScript are much faster than Java and C# for AWS Lambda (serverless computing.) So I'm curious to what degree you can swap out the runtime with the same code

Yeah, interesting. WASM is actually even better in some ways -- its an intermediate representation. Languages compile to WASM, and WASM can run on various runtimes...

Languages today are inextricably linked with very complex runtimes. You can't even consider running Elixir or Erlang without the special virtual machine. That runtime has a very clever heap-per-thread architecture, unique among languages, and if you have a task to do that requires 300,000 simultaneous threads, you are going to get pounded with memory management problems in any conventional runtime. Languages also don't agree on data types. C has a 2 value boolean. JS has a 3-value boolean (undefined, true, false), and Beads has a 4-value boolean (undefined, error, true, false) in order to have a uniform top and bottom value for all data types. These types of minute details make data interchange basically impractical between languages, so the idea of a universal runtime is unrealistic in this universe.

there was an attempt a (long?) time ago called parrot to provide a vm for multiple dynamic languages: https://en.wikipedia.org/wiki/Parrot_virtual_machine

This is also relevant: https://tratt.net/laurie/blog/entries/fine_grained_language_composition.html

People help each other, share each other's code. It would be very inconvenient if people used many different syntaxes for same language

One thing that would make that hard is translating the standard library/built in types. You not only would have to translate the code you’re working with, but everything it depends on. At that point, what’s the benefit?

Counterpoint to @Vladimir Gordeev’s comment: "We can make machines do it any way we like, and we can have policies that can allow you to do both. Remember, a real engineer doesn't want just a religion about how to solve a problem, like object-oriented, or functional, or imperative, or logic programming. This piece of the problem wants to be a functional program. This piece of the program wants to be imperative. This piece wants to be object-oriented. And guess what, this piece wants to be logic-based. And they all want to work together usefully. And that's because of the way the problem is structured, whatever it is. And I don't wanna think that there's any correct answer to any of those questions. It would be awful bad writing a device driver in a functional language. It would be awful bad writing anything like a symbolic manipulator in a thing with complicated syntax. It's awful bad to write a numerical program in anything but Fortran." —Gerald Sussman

@noahtren My work at http://loyc.net is specifically aimed at solving bits of that problem. I'd like to build a system that will have syntax modules, semantic modules, and a multi-language standard library.

re: hard to share across inconsistent languages Maybe that would look different if there was one common representation, and other languages were just (or could be added as) projections to/from it. I think that would fit in with what David is doing with LOYC?