Why are Rust executables so huge How would you optimise it

Rust executables are often larger than those produced by other languages like C or C++ due to several factors:

Static Linking: Rust statically links its standard library and other dependencies into the binary. This is in contrast to languages like C, which often dynamically link their standard libraries, resulting in smaller binaries[2][6].
Debug Symbols: By default, Rust includes debug symbols in the compiled binaries, which significantly increases their size. These symbols are useful for debugging but are not necessary for the final executable[1][2][4].
Monomorphization: Rust uses monomorphization to generate specific versions of generic functions for each type they are used with. This can lead to code bloat as multiple versions of the same function are included in the binary[2][11].
Panic Handling and Stack Traces: Rust includes mechanisms for panic handling and generating stack traces, which add to the binary size. These features are included by default to ensure robust error handling[2][5].

To reduce the size of Rust executables, several techniques can be employed:

Release Mode: Always compile in release mode using cargo build --release. This enables optimizations that reduce the binary size and improve performance[7][8].
Stripping Debug Symbols: Use the strip command to remove debug symbols from the binary. This can be done manually or configured in Cargo.toml:
```
[profile.release]
strip = true
```
This can significantly reduce the binary size[2][5][11].
Optimization Levels: Adjust the optimization level in Cargo.toml to prioritize size over speed:
```
[profile.release]
opt-level = "z"  # Optimize for size
```
Alternatively, use opt-level = "s" for a balance between size and performance[8][11].
Link-Time Optimization (LTO): Enable LTO to perform optimizations across the entire program at link time:
```
[profile.release]
lto = true
```
This can help reduce the binary size by eliminating redundant code[3][8].
Custom Panic Handlers: Replace the default panic handler with a custom one that does not include stack traces:

Why are Rust executables so huge? How would you optimise it?