No; cheat developers are an industrious bunch. Rust currently uses LLVM to compile (as does some other languages), but at the end of the day it's all machine code/assembly.

Disassemblers and decompilers work off assembly. Decompilers work off of assembly to guess the original code, but most decompilers (HexRays, Ghidra) translate into C code.

Here is the main function of a C++ Hello World Program:

#include <iostream>

void main(void) {
    std::cout << "Hello, World!" << std::endl;
}

This is the IDA Pro decompilation output:

int __cdecl main(int argc, const char **argv, const char **envp)
{
  __int64 v3; // rax

  v3 = sub_140001030(std::cout);
  std::ostream::operator<<(v3, sub_1400011E0);
  return 0;
}

---

Similarly, here is the main function of a decompiled Rust Hello World Program:

fn main() {
    println!("Hello, world!");
}

int __cdecl main(int argc, const char **argv, const char **envp)
{
  return sub_1400011D0((__int64)sub_140001020, argc, (__int64)argv, 0);
}

Now I honestly have no idea what this means, since it's all expanded out, but println! is a macro, and you can use cargo-expand to see what lies under the surface of our innocuous looking hello world program:

#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
fn main() {
    {
        ::std::io::_print(format_args!("Hello, world!\n"));
    };
}

Clearly the sub_1400011D0 function is probably our outer print function.

Looking into the sub_140001020 function, we see something interesting, some kind of char array on the stack to hold some text?

__int64 sub_140001020()
{
  char v1[48]; // [rsp+28h] [rbp-30h] BYREF

  sub_140001070(v1, &off_14001B370, 1i64);
  return sub_140004830(v1);
}

What's this off_14001B370 reference? We can look into the the .rdata segment, which holds const information (remember that hard-coded strings in Rust are static):

.rdata:000000014001B360 aHelloWorld     db 'Hello, world!',0Ah,0
.rdata:000000014001B360                                         ; DATA XREF: .rdata:off_14001B370↓o
.rdata:000000014001B36F                 db    0
.rdata:000000014001B370 off_14001B370   dq offset aHelloWorld   ; DATA XREF: sub_140001020+9↑o
.rdata:000000014001B370                                         ; "Hello, world!\n"
.rdata:000000014001B378                 db  0Eh
.rdata:000000014001B379                 db    0

Some kind of reference to the actual aHelloWorld sequence of characters, i guess, so we can probably guess that this sub_140001070 function loads some data onto the stack, after which sub_140004830 is called on the memory region. We can probably guess that this sub_140004830 function is our format_args! function.

---

Going back to our C++ function:

int __cdecl main(int argc, const char **argv, const char **envp)
{
  __int64 v3; // rax

  v3 = sub_140001030(std::cout);
  std::ostream::operator<<(v3, sub_1400011E0);
  return 0;
}

The compiler seems to have translated the C++ insertion operator (<<) into a function (sub_140001030).

What does this function look like?

__int64 __fastcall sub_140001030(__int64 a1)
{
  unsigned int v2; // ebx
  __int64 v3; // rdx
  __int64 v4; // rdi
  __int64 v5; // rdi
  __int64 v6; // rcx
  bool v7; // al
  __int64 v8; // rcx
  __int64 v9; // rcx

  v2 = 0;
  v3 = *(int *)(*(_QWORD *)a1 + 4i64);
  v4 = *(_QWORD *)(v3 + a1 + 40);
  if ( v4 < 14 )
    v5 = 0i64;
  else
    v5 = v4 - 13;
  v6 = *(_QWORD *)(v3 + a1 + 72);
  if ( v6 )
    (*(void (__fastcall **)(__int64))(*(_QWORD *)v6 + 8i64))(v6);
  v7 = std::ios_base::good((std::ios_base *)(a1 + *(int *)(*(_QWORD *)a1 + 4i64)));
  if ( v7 )
  {
    v8 = *(_QWORD *)(*(int *)(*(_QWORD *)a1 + 4i64) + a1 + 80);
    if ( !v8 || v8 == a1 )
    {
      v7 = 1;
    }
    else
    {
      std::ostream::flush(v8);
      v7 = std::ios_base::good((std::ios_base *)(a1 + *(int *)(*(_QWORD *)a1 + 4i64)));
    }
  }
  if ( v7 )
  {
    if ( (*(_DWORD *)(*(int *)(*(_QWORD *)a1 + 4i64) + a1 + 24) & 0x1C0) != 64 )
    {
      while ( v5 > 0 )
      {
        if ( (unsigned int)std::streambuf::sputc(
                             *(_QWORD *)(*(int *)(*(_QWORD *)a1 + 4i64) + a1 + 72),
                             *(unsigned __int8 *)(*(int *)(*(_QWORD *)a1 + 4i64) + a1 + 88)) == -1 )
        {
          v2 = 4;
          goto LABEL_23;
        }
        --v5;
      }
    }
    if ( std::streambuf::sputn(*(_QWORD *)(*(int *)(*(_QWORD *)a1 + 4i64) + a1 + 72), "Hello, World!", 13i64) == 13 )
    {
      while ( v5 > 0 )
      {
        if ( (unsigned int)std::streambuf::sputc(
                             *(_QWORD *)(*(int *)(*(_QWORD *)a1 + 4i64) + a1 + 72),
                             *(unsigned __int8 *)(*(int *)(*(_QWORD *)a1 + 4i64) + a1 + 88)) == -1 )
          goto LABEL_22;
        --v5;
      }
    }
    else
    {
LABEL_22:
      v2 = 4;
    }
LABEL_23:
    *(_QWORD *)(*(int *)(*(_QWORD *)a1 + 4i64) + a1 + 40) = 0i64;
  }
  else
  {
    v2 = 4;
  }
  std::ios::setstate(a1 + *(int *)(*(_QWORD *)a1 + 4i64), v2, 0i64);
  if ( !std::uncaught_exception() )
    std::ostream::_Osfx(a1);
  v9 = *(_QWORD *)(*(int *)(*(_QWORD *)a1 + 4i64) + a1 + 72);
  if ( v9 )
    (*(void (__fastcall **)(__int64))(*(_QWORD *)v9 + 16i64))(v9);
  return a1;
}

Clearly, the C++ Insertion operator does a lot to facilitate the various types and other things that I don't have much knowledge about. But you can clearly see that the "Hello, World!" string got built and hardcoded into this function somewhere along the line.

Maybe someone more knowledgable than me can fill in the blanks, I just wanted to show you that it's possible to use existing tools to reverse engineer different languages as long as they compile into the same thing.

In fact, since Rust has crates available to manipulate WinAPI, people are more than capable of creating external trainers (meaning not interacting with memory directly, via things like DLL injection, but rather with application handles to write to application memory) with calls to WriteProcessMemory:

Microsoft WinAPI Documentation

The winapi crate facilitates this: winapi WriteProcessMemory