Mefistophell · August 29, 2025 16:15 · Jul 7, 2023 · Jan 28, 2020 · Jan 28, 2020 · Jan 28, 2020
diff --git a/RUST.MD b/RUST.MD
@@ -1,6 +1,6 @@
-#### **Q**: I want to compile my Rust source code for the Windows platform, but I work on macOS.
+#### **Question**: I want to compile my Rust source code for the Windows platform but I use macOS.
 
-### Solution
+### Solution:
 
 1. Install target mingw-w64: `brew install mingw-w64`
 2. Add target to rustup: `rustup target add x86_64-pc-windows-gnu`
@@ -10,22 +10,22 @@
 [target.x86_64-pc-windows-gnu]
 linker = "x86_64-w64-mingw32-gcc"
 ```
-5. If it hasn't work this is supposed to help: 
+5. If it's not working try to run the following command: 
 ```
 cp -f /usr/local/Cellar/mingw-w64/7.0.0_1/toolchain-x86_64/x86_64-w64-mingw32/lib/{,dll}crt2.o `rustc --print sysroot`/lib/rustlib/x86_64-pc-windows-gnu/lib
 ```
 6. And finally, run: `cargo build --target=x86_64-pc-windows-gnu --verbose`
 
 ### Useful commands: 
-`rustup show` shows targets amn toolchain
+`rustup show` — shows targets amn toolchain
 
-`rustup target list` shows all supported targets.
+`rustup target list` — shows all supported targets
 
 **A bit of theory:**
 
-To compile your source code for another platform, you need to specify a target. This tells the compiler which platform your code should be compiled for. For this reason, you need to install the appropriate GCC, the GNU Compiler Collection for Windows. Like this one [mingw-w64](https://formulae.brew.sh/formula/mingw-w64). 
+To compile a source code for a platform different from your local, you need to specify a target. This tells the compiler which platform your code should be compiled for. For this reason, you need to install the appropriate GCC, the GNU Compiler Collection for Windows. Like this one: [mingw-w64](https://formulae.brew.sh/formula/mingw-w64). 
 
-Then you should add a target to a Rust toolchain. 
+Then you should add the target to the Rust toolchain. 
 
 > *Toolchains* are a set of linked tools that help the language produce a functional target code. They can provide extended functionality from either a simple compiler and linker program, or additional libraries
 

diff --git a/RUST.MD b/RUST.MD
@@ -23,7 +23,7 @@ cp -f /usr/local/Cellar/mingw-w64/7.0.0_1/toolchain-x86_64/x86_64-w64-mingw32/li
 
 **A bit of theory:**
 
-To compile your source code for another platform, you need to specify a target. This tells the compiler which platform your code should be compiled for. For this reason, you need to install the appropriate GCC, the GNU Compiler Collection for Windows. Like this one [https://formulae.brew.sh/formula/mingw-w64](mingw-w64). 
+To compile your source code for another platform, you need to specify a target. This tells the compiler which platform your code should be compiled for. For this reason, you need to install the appropriate GCC, the GNU Compiler Collection for Windows. Like this one [mingw-w64](https://formulae.brew.sh/formula/mingw-w64). 
 
 Then you should add a target to a Rust toolchain. 
 

diff --git a/RUST.MD b/RUST.MD
@@ -40,4 +40,5 @@ Links:
 - [Cargo configuration](https://doc.rust-lang.org/cargo/reference/config.html)
 - [Introduction to the compiler, linker, and libraries](https://www.learncpp.com/cpp-tutorial/introduction-to-the-compiler-linker-and-libraries/)
 - [Github issue: Can't cross compile from Linux to Windows](https://github.com/rust-lang/rust/issues/32859)
-- [Github issue: Cannot link with C code using stdout](https://github.com/rust-lang/rust/issues/47048)
+- [Github issue: Cannot link with C code using stdout](https://github.com/rust-lang/rust/issues/47048)
+- [Rust Toolchains](https://medium.com/@nsdchrisu/rust-is-distributed-on-a-stable-nightly-and-beta-release-channels-5ebf18126c0d)
diff --git a/RUST.MD b/RUST.MD
@@ -21,7 +21,7 @@ cp -f /usr/local/Cellar/mingw-w64/7.0.0_1/toolchain-x86_64/x86_64-w64-mingw32/li
 
 `rustup target list` shows all supported targets.
 
-**A bit of theory: **
+**A bit of theory:**
 
 To compile your source code for another platform, you need to specify a target. This tells the compiler which platform your code should be compiled for. For this reason, you need to install the appropriate GCC, the GNU Compiler Collection for Windows. Like this one [https://formulae.brew.sh/formula/mingw-w64](mingw-w64). 
 
@@ -36,8 +36,8 @@ The next step is to add a linker. This can be set in the *Cargo config*
 When the linker is added you can build a program. 
 
 Links: 
-- [https://formulae.brew.sh/formula/mingw-w64](Download mingw-w64 via Homebrew)
-- [https://doc.rust-lang.org/cargo/reference/config.html](Cargo configuration)
-- [https://www.learncpp.com/cpp-tutorial/introduction-to-the-compiler-linker-and-libraries/](Introduction to the compiler, linker, and libraries)
-- [https://github.com/rust-lang/rust/issues/32859](Github issue: Can't cross compile from Linux to Windows)
-- [https://github.com/rust-lang/rust/issues/47048](Github issue: Cannot link with C code using stdout)
+- [Download mingw-w64 via Homebrew](https://formulae.brew.sh/formula/mingw-w64)
+- [Cargo configuration](https://doc.rust-lang.org/cargo/reference/config.html)
+- [Introduction to the compiler, linker, and libraries](https://www.learncpp.com/cpp-tutorial/introduction-to-the-compiler-linker-and-libraries/)
+- [Github issue: Can't cross compile from Linux to Windows](https://github.com/rust-lang/rust/issues/32859)
+- [Github issue: Cannot link with C code using stdout](https://github.com/rust-lang/rust/issues/47048)
diff --git a/RUST.MD b/RUST.MD
@@ -1,17 +1,43 @@
+#### **Q**: I want to compile my Rust source code for the Windows platform, but I work on macOS.
+
+### Solution
+
 1. Install target mingw-w64: `brew install mingw-w64`
 2. Add target to rustup: `rustup target add x86_64-pc-windows-gnu`
-3. Create .cargo/config
+3. Create `.cargo/config`
 4. Add the instructions below to `.cargo/config` 
 ```
 [target.x86_64-pc-windows-gnu]
 linker = "x86_64-w64-mingw32-gcc"
 ```
-5. Fix cert
+5. If it hasn't work this is supposed to help: 
 ```
 cp -f /usr/local/Cellar/mingw-w64/7.0.0_1/toolchain-x86_64/x86_64-w64-mingw32/lib/{,dll}crt2.o `rustc --print sysroot`/lib/rustlib/x86_64-pc-windows-gnu/lib
 ```
 6. And finally, run: `cargo build --target=x86_64-pc-windows-gnu --verbose`
 
-Useful commands: 
-rustup show
-rustup target list
+### Useful commands: 
+`rustup show` shows targets amn toolchain
+
+`rustup target list` shows all supported targets.
+
+**A bit of theory: **
+
+To compile your source code for another platform, you need to specify a target. This tells the compiler which platform your code should be compiled for. For this reason, you need to install the appropriate GCC, the GNU Compiler Collection for Windows. Like this one [https://formulae.brew.sh/formula/mingw-w64](mingw-w64). 
+
+Then you should add a target to a Rust toolchain. 
+
+> *Toolchains* are a set of linked tools that help the language produce a functional target code. They can provide extended functionality from either a simple compiler and linker program, or additional libraries
+
+The next step is to add a linker. This can be set in the *Cargo config* 
+
+> The Rust compiler sequentially goes through each source code file in your program and checks your code to make sure it follows the rules of the Rust language and translates your source code into a machine language file called an object file. After the compiler creates one or more object files, then another program called the **linker** take all the object files generated by the compiler and combine them into a single executable program. In addition to being able to link object files, the **linker** also is capable of linking library files. A library file is a collection of precompiled code that has been “packaged up” for reuse in other programs. 
+
+When the linker is added you can build a program. 
+
+Links: 
+- [https://formulae.brew.sh/formula/mingw-w64](Download mingw-w64 via Homebrew)
+- [https://doc.rust-lang.org/cargo/reference/config.html](Cargo configuration)
+- [https://www.learncpp.com/cpp-tutorial/introduction-to-the-compiler-linker-and-libraries/](Introduction to the compiler, linker, and libraries)
+- [https://github.com/rust-lang/rust/issues/32859](Github issue: Can't cross compile from Linux to Windows)
+- [https://github.com/rust-lang/rust/issues/47048](Github issue: Cannot link with C code using stdout)
diff --git a/RUST.MD b/RUST.MD
@@ -0,0 +1,17 @@
+1. Install target mingw-w64: `brew install mingw-w64`
+2. Add target to rustup: `rustup target add x86_64-pc-windows-gnu`
+3. Create .cargo/config
+4. Add the instructions below to `.cargo/config` 
+```
+[target.x86_64-pc-windows-gnu]
+linker = "x86_64-w64-mingw32-gcc"
+```
+5. Fix cert
+```
+cp -f /usr/local/Cellar/mingw-w64/7.0.0_1/toolchain-x86_64/x86_64-w64-mingw32/lib/{,dll}crt2.o `rustc --print sysroot`/lib/rustlib/x86_64-pc-windows-gnu/lib
+```
+6. And finally, run: `cargo build --target=x86_64-pc-windows-gnu --verbose`
+
+Useful commands: 
+rustup show
+rustup target list