Hard disagree. Super beautiful.

Almost any language is ok but some ecosystems make me want to turn into a murder hobo (looking at you, JavaScript).

what? what part of rust is ugly?

FORTRAN isn't a beauty either.
And Python is strange as hell with its mandatory tabs.

I can actually see where this is coming from, as I found Rust hard to read when I started out. I do really like Rust for reference, but I do agree Rust is hard to read for someone that has not learned it.

For example:

return statements that are implicit just because the semicolon isn't there. Even better if they occur inside a if block or something like that. Very hard to understanding when you don't know the syntax rules.

Lambda functions, especially when using move semantics too. They are quite simple, but if you don't know the meaning, it's more arcane characters. Especially when this is used inside lots of chained methods, and maybe a multi-line function in the lambda.

A lot for the if let x =... type of stataments are tough the first time around. Same for match statements.

Defining types for use with function::() and such.

Lifetimes, especially when they are all named a, b, c etc. It quickly gets messy, especially when combined with generics or explicitly defined types.

Macros, though not entry level rust to begin with, they are really cumbersome to decode.

None of these are sins of Rust, but for new people they are a hill to climb, and often hard to just "get" based on previous programming experience and reading the code. Rust can be really hard to approach because of these things. This happens in other languages too, but I do feel Rust has a particularly large amount of new concepts or ways to do something. And this is on top of learning lifetimes and borrow semantics.

One of the reasons i find it so hard to use non-Rust languages is how ugly they typically are by comparison. "fn" instead of "function" is such a great example of saving key presses where they're most needed. And you get very used to seeing compact abbreviations. Idk if that's what you're talking about though.

Go look at that Lisp kojumbo then tell me Rust is ugly.

(defmethod wake ((object magic-packet) address port)
  (let* ((payload (encode-payload object))
         (size (length payload))
         (socket (usocket:socket-connect nil nil :protocol :datagram :element-type '(unsigned-byte 8))))
    (setf (usocket:socket-option socket :broadcast) t)
    (usocket:socket-send socket payload size :host address :port port)
    (usocket:socket-close socket)))

Actually unreadable.

Not to stereotype too much but I think this is the first Blåhaj I've seen (in a programming context) that wasn't team Rust.

What your programming language of choice (if you don't mind sharing)?