Mundane typing? Typing is awesome! Haven't you ever wondered what a parameter actually is in say, Python, and have to track back through callers to work out what the parameter is expected to contain? Completely solved by specifying type.

Nim has really good type inference, so the 'mundane' aspect I guess you're referring to isn't there.

  let
    myStr = "Hello"
    myInt = 12
    myFloat = 1.2
  var myHashTable = newTable[string, int]()

The need for checking types at runtime is of course completely eliminated in typed languages so you get that for free. Nim also offers an extension to this with distinct types.

  type
    Euros = distinct float   # NB: Don't use float for currency
    Dollars = distinct float
  let
    a = 10.Dollars
    b = 10.Euros
    c = a + b  # Compile time error
    d = a + 1  # Compile time error

  proc dollars(e: Euros): Dollars =
    let exchangeRate = 1.117
    result = (e.float * exchangeRate).Dollars

  proc euros(d: Dollars): Euros =
    let exchangeRate = 0.858
    result = (d.float * exchangeRate).Euros

  let
    e = a.euros
    f = b.dollars

  echo e.float  # 8.58
  echo f.float  # 11.17

> I have come to believe transpiling is the devil and many-languages syndrome is very counterproductive

Why do you believe this? In Nim the language creates an AST and it's this that is output in various forms. The underlying representation is the same, but it allows many targets. Similar to LLVM (which is also a Nim target, if unofficially), it's one of the reasons why it can compile on almost every platform, and why it is a good choice for the low resource devices that projects like Nimbus target.

It also means you can write servers and clients in the same language but target C and JavaScript, respectively.