Is implicit typing in Rust always guaranteed to have the same behavior?

Let's say I define a variable using "let x = 5"

Rust will implicitly assign a type to this variable. Is it absolutely guaranteed on every platform that the type it implicitly assigns is always the same?

I've been coding in C for decades and probably one of my biggest complaints isn't even the fact it's not memory safe but the fact that the language itself is platform dependent. You always have to add a compatibility layer like "stdint.h" which is a layer of code you add on top of your C code to make it compatible with other platforms because the behavior of keywords in C aren't consistent from platform to platform.

For example "char" and "int" may be defined differently. And if someone wrote their program without that compatibility layer? Well good luck with endless frustrations trying to port their code to another platform.

While I will probably continue to use C because it has good legacy support, I've been considering trying a different language for newer projects that are more platform-independent for portability reasons, and have been looking at Rust, but I saw Rust has implicit typing and this immediately worries me so I was wondering if anyone here could clarify if it's absolutely guaranteed in the Rust standard that implicit typing has the same behavior in all cases.

If this isn't platform dependent, is there anything else that might be?

It might seem like a silly question but I just want to verify before dedicating any time into this language that it won't just reproduce the same frustrations I have with C over the years.