<!-- FORMAT: rich_text -->
<!-- AST_B64: [{"id":"block_1792760791249","type":"heading","content":[{"type":"text","text":"C Programming Part 2: How to Set Up C on Windows and Run Your First Program<br>"}],"children":[],"props":{"level":2}},{"id":"block_1792760799280","type":"paragraph","content":[{"type":"text","text":"<br>Hello hello from GDR!<br>Hello hello, guys! Welcome back to another tutorial.<br>In Part 1, we learned what C Language is, why it is important, and why we should learn it even when languages like Python, Java, and JavaScript already exist.<br>Now it's time to stop talking and start doing something.<br>Today, we are going to set up C Programming on our Windows computer, install a compiler, write our first C program, and run it successfully.<br>And don't worry. You don't need a ₹1 lakh gaming laptop, 64 GB RAM, or a NASA computer to run a simple C program.<br>If your laptop can open a browser without turning into a heater, we can probably get started.<br>Let's begin!Watch the original video<br>Here is my original setup tutorial. Watch it alongside this written guide.<br>The video uses an older MinGW installation method. Below, I'll explain a recommended setup for new Windows installations and clarify the technical points that beginners often misunderstand.1. What do we need to start C Programming?<br>Before writing code, we need two things.<br>First, a code editor.<br>A code editor is where we write our code. We can use Visual Studio Code, Notepad++, or even Notepad.<br>Second, a compiler.<br>A compiler translates our C source code into a form that the computer can execute.<br>For this tutorial, we'll use GCC, which stands for GNU Compiler Collection.<br>GCC supports several programming languages, including C and C++.<br>Remember, installing VS Code does not automatically mean you have installed a C compiler. VS Code is where you write your code, while GCC compiles it.<br>Installing a code editor and expecting C to work automatically is like buying a notebook and expecting your homework to complete itself.<br>If that worked, every student would have a 10 CGPA and absolutely no idea how they got it.2. Installing C on Windows<br>We'll use MSYS2 with the UCRT64 GCC toolchain. This is a recommended approach for a fresh Windows installation.<br>Official websites:<br>MSYS2: <a href=\"https://www.msys2.org/?utm_source=chatgpt.com\">https://www.msys2.org/</a><br>Microsoft's VS Code C/C++ setup guide: <a href=\"https://code.visualstudio.com/docs/cpp/config-mingw?utm_source=chatgpt.com\">https://code.visualstudio.com/docs/cpp/config-mingw</a>Step 1: Download MSYS2<br>Open your browser and visit <a href=\"https://www.msys2.org/?utm_source=chatgpt.com\">https://www.msys2.org/</a>.<br>Download the official installer and install it. Unless you have a specific reason to change it, keep the default installation folder:<br><code>C:\\msys64</code><br>Please download it from the official website. Don't download random files called <code>GCC_FINAL_REAL_FIXED_2026.exe</code> from suspicious websites.<br>We're trying to become programmers, not the main character of a cybersecurity incident report."}],"children":[],"props":{}},{"id":"block_1792760828960","type":"paragraph","content":[{"type":"text","text":"Step 2: Open the MSYS2 UCRT64 terminal<br>Open your Windows Start menu and search for:<br><code>MSYS2 UCRT64</code><br>Launch it.<br>First, update the MSYS2 packages:<code></code>"}],"children":[],"props":{}},{"id":"block_1792760846304","type":"code_block","content":[{"type":"text","text":"pacman -Syu"}],"children":[],"props":{"language":"shell","code":""}},{"id":"block_1792760879741","type":"paragraph","content":[{"type":"text","text":"<br>Follow the instructions displayed in the terminal. If it asks you to close the terminal after updating, close it, reopen the UCRT64 terminal, and follow any remaining update instructions.<br>Now install GCC and the development tools:<code></code>"}],"children":[],"props":{}},{"id":"block_1792760894819","type":"html","content":[{"text":"<!-- SANDBOX_START -->\n<iframe width=\"991\" height=\"557\" src=\"https://www.youtube.com/embed/2o2xX4q9Iuo\" title=\"How to Set Up GCC C Language Compiler on Windows and Linux | Step-by-Step Guide\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen></iframe>\n<!-- SANDBOX_SEP -->\n\n<!-- SANDBOX_SEP -->\n\n<!-- SANDBOX_END -->"}],"children":[],"props":{}},{"id":"block_1792760910938","type":"code_block","content":[{"type":"text","text":"pacman -S --needed base-devel mingw-w64-ucrt-x86_64-toolchain"}],"children":[],"props":{"language":"shell","code":""}},{"id":"block_1792760950391","type":"paragraph","content":[{"type":"text","text":"<br>If it asks you to choose packages from the toolchain group, press Enter to accept the default selection. When asked to proceed, type <code>Y</code> and press Enter.<br>Wait for the installation to finish.<br>It might take a while depending on your internet connection. Don't close the terminal halfway through because you're bored. The compiler is installing, not writing a suspense thriller.Step 3: Add GCC to PATH<br>Now we need to make GCC accessible from Windows Command Prompt.<br>If you used the default MSYS2 installation location, the GCC executable folder should be:<br><code>C:\\msys64\\ucrt64\\bin</code><br>Copy this path.<br>Then follow these steps:<br>Open the Windows Start menu.<br>Search for Edit environment variables for your account.<br>Open the settings.<br>Find the <code>Path</code> variable under your user variables.<br>Click Edit.<br>Click New.<br>Paste <code>C:\\msys64\\ucrt64\\bin</code>.<br>Click OK to save your changes.<br>Do not delete your existing PATH entries. Simply add the new one.<br>And please don't randomly delete every entry because you saw a YouTube comment saying it fixes everything. We are installing a compiler, not speedrunning Windows repair.<br>Close any previously opened Command Prompt or terminal windows, then open a new one so it receives the updated PATH."}],"children":[],"props":{}},{"id":"block_1792760965883","type":"heading","content":[{"type":"text","text":"Step 4: Check whether GCC is installed<br>"}],"children":[],"props":{"level":2}},{"id":"block_1792760971162","type":"paragraph","content":[{"type":"text","text":"<br>Press <code>Win + R</code>, type <code>cmd</code>, and press Enter.<br>Now run:"}],"children":[],"props":{}},{"id":"block_1792760984724","type":"code_block","content":[{"type":"text","text":"gcc --version"}],"children":[],"props":{"language":"shell","code":""}},{"id":"block_1792761017491","type":"paragraph","content":[{"type":"text","text":"<br>If everything is configured correctly, you should see GCC version information.<br>The exact output will depend on the version you installed.<br>If Windows says:<br><code>'gcc' is not recognized as an internal or external command</code><br>it means Windows cannot find GCC. The compiler might not be installed properly, or its folder might be missing from PATH.<br>Check your installation and PATH entry before trying again.<br>Remember, <code>gcc --version</code> confirms that Windows can find GCC. We'll still compile a real program to test that everything works.3. Write your first C program<br>Congratulations! We've installed the compiler.<br>Now let's write some actual code.<br>Create a folder on your Desktop called:<br><code>C-Practice</code><br>Inside that folder, create a file called:<br><code>main.c</code><br>Make sure the filename really ends with <code>.c</code>, not <code>.txt</code>.<br>Windows sometimes hides file extensions by default, so you can enable View → Show → File name extensions in File Explorer to check.<br>Now open <code>main.c</code> in VS Code or your preferred text editor and write this code:"}],"children":[],"props":{}},{"id":"block_1792761120290","type":"code_block","content":[{"type":"text","text":"\n#include &lt;stdio.h&gt;<br><br><br><br>int main(void)<br><br>{<br><br>    printf(\"Hello, World!\\n\");<br><br>    return 0;<br><br>}\n\n"}],"children":[],"props":{"language":"cpp","code":""}},{"id":"block_1792761138455","type":"paragraph","content":[{"type":"text","text":"<br>Let's understand what we wrote.<code>#include &lt;stdio.h&gt;</code><br>This includes the standard input/output header, which declares functions such as <code>printf()</code>.<code>int main(void)</code><br>This defines the main function, where execution of a normal hosted C program begins.<code>printf(\"Hello, World!\\n\");</code><br>This displays <code>Hello, World!</code> on the screen.<br>The <code>\\n</code> moves the output to a new line.<code>return 0;</code><br>This indicates successful termination when the program reaches the return statement in a normal hosted environment.<br>It doesn't prevent every possible error. It simply returns a status value.Why is there a semicolon?<br>In C, most statements end with a semicolon.<br>Forget one in the wrong place, and the compiler might complain.<br>The compiler isn't angry with you. It doesn't even know you exist.<br>It simply follows the rules, unlike that one friend who still hasn't returned your ₹500.4. Compile and run your first program<br>Now we need to compile the code.<br>Open your <code>C-Practice</code> folder in VS Code. Select Terminal, then New Terminal.<br>Make sure the terminal is inside the folder containing <code>main.c</code>.<br>You can check by running:<code>dir</code><br>You should see <code>main.c</code> in the output.Step 1: Compile the program<br>Run:<code>gcc main.c -o main.exe</code><br>Here's what the command means:<br><code>gcc</code> runs the compiler.<br><code>main.c</code> is your source file.<br><code>-o main.exe</code> tells GCC to name the output program <code>main.exe</code>.<br>If compilation succeeds, GCC will usually return to the terminal without displaying an error message.<br>You should now have a new file called <code>main.exe</code>.Step 2: Run the program<br>If you're using Command Prompt, run:<code>main.exe</code><br>If you're using PowerShell, run:<code>.\\main.exe</code><br>Your output should be:<code>Hello, World!</code><br>And there you go!<br>You've written, compiled, and executed your first C program.<br>Congratulations. You've made your computer display two words and a comma.<br>Microsoft might not hire you just yet, but everybody starts somewhere.5. What actually happens when we compile C code?<br>Let's understand something important.<br>When we write C code, we're writing source code that the processor cannot execute directly in its original form.<br>The compiler toolchain processes the source code and produces a program for the target system.<br>A typical GCC build involves several stages:<br>Preprocessing<br>Compilation<br>Assembly<br>Linking<br>We'll explore these stages in more detail later.<br>For now, remember this:<br>C source code → Compiler toolchain → Executable program → Output<br>Compiling is not simply changing the extension from <code>.c</code> to <code>.exe</code>.<br>Renaming a file doesn't transform its contents. Otherwise, we could rename our exam paper to <code>full_marks.pdf</code> and become toppers overnight.<br>Sadly, the education system hasn't implemented that feature.6. Common Windows problems and their solutionsProblem 1: GCC is not recognised<br>Check that GCC is installed and that the correct folder is in PATH.<br>For the default MSYS2 UCRT64 installation, that folder is:<br><code>C:\\msys64\\ucrt64\\bin</code><br>Open a new terminal after changing PATH."}],"children":[],"props":{}},{"id":"block_1792761171955","type":"heading","content":[{"type":"text","text":"Problem 2: The compiler shows errors<br>"}],"children":[],"props":{"level":2}},{"id":"block_1792761185580","type":"paragraph","content":[{"type":"text","text":"<br>Check your code for missing semicolons, misspelled function names, unmatched braces, or missing quotation marks.<br>For example, this code is missing a semicolon:<code>printf(\"Hello, World!\\n\")</code><br>The correct version is:<code>printf(\"Hello, World!\\n\");</code><br>Read the compiler's error message carefully. It often gives you a useful starting point.Problem 3: The program compiles but doesn't run<br>Check whether <code>main.exe</code> exists by running:<code>dir</code><br>Then run the correct filename.<br>In Command Prompt:<code>main.exe</code><br>In PowerShell:<code>.\\main.exe</code><br>Also make sure you're running the executable you just compiled, not an older version left over from a previous attempt.Problem 4: Nothing appears on the screen<br>Check whether your program actually contains a <code>printf()</code> statement and whether you are running the correct executable.<br>If compilation fails, an older executable might still exist. That can make it look as though your latest code worked when you're actually running yesterday's version.<br>Always check for compiler errors before running the program.7. A quick look at Linux<br>Our main focus is Windows, but here's the basic setup for Linux users.<br>On Ubuntu, Debian, and Kali Linux, you can generally install GCC using:<code>sudo apt update\nsudo apt install build-essential</code><br>Then check:<code>gcc --version</code><br>Create a file called <code>main.c</code> containing:<code>#include &lt;stdio.h&gt;\n\nint main(void)\n{\n    printf(\"Hello from GDR!\\n\");\n    return 0;\n}</code><br>Compile it:<code>gcc main.c -o hello</code><br>Run it:<code>./hello</code><br>The output should be:<code>Hello from GDR!</code><br>Notice that we used <code>hello</code> without an extension.<br>Linux executables do not generally require a <code>.exe</code> or <code>.out</code> extension. GCC may create a file named <code>a.out</code> when you don't specify an output filename, but you can choose your own name using <code>-o</code>.<br>Windows and Linux also use different executable formats and system interfaces. A native executable built for one operating system does not automatically run as a native program on the other.8. Important corrections to my original video<br>Since this tutorial updates my original setup video, here are the important clarifications.<br>1. The Windows installation method is older. The original video uses MinGW Installation Manager. For a fresh installation, this guide recommends MSYS2 with UCRT64 GCC.<br>2. Adding GCC to PATH does not install GCC. You must install the compiler first. PATH helps Windows locate it.<br>3. <code>gcc --version</code> is only the first check. Compiling and running a real program is a better test of the complete setup.<br>4. <code>return 0;</code> does not prevent all errors. It normally indicates successful termination when reached. It does not guarantee that your program is free from bugs.<br>5. Linux does not require <code>.out</code> for executables. The filename extension is not what makes a file executable.<br>6. Compiling is not renaming. The compiler toolchain processes your source code and builds a program for the target system.<br>These corrections will help you follow the original video while learning the process accurately.9. Your first programming challenge<br>Now let's see whether you can write a small program yourself.<br>Your task is to display the following output:<code>Hello, World!\nHello from GDR!\nI am learning C Programming.\nMy journey starts today!</code><br>Try writing the program before looking at the solution.<br>Here's one possible answer:<code>#include &lt;stdio.h&gt;\n\nint main(void)\n{\n    printf(\"Hello, World!\\n\");\n    printf(\"Hello from GDR!\\n\");\n    printf(\"I am learning C Programming.\\n\");\n    printf(\"My journey starts today!\\n\");\n\n    return 0;\n}</code><br>Compile and run it using the steps you learned above.<br>If it works, excellent.<br>If it doesn't, don't immediately copy someone else's code. Read the error, check your work, and try to understand what went wrong.<br>Debugging is part of programming. It doesn't mean you're bad at it."}],"children":[],"props":{}}] -->
## C Programming Part 2: How to Set Up C on Windows and Run Your First Program<br>
<br>Hello hello from GDR!<br>Hello hello, guys! Welcome back to another tutorial.<br>In Part 1, we learned what C Language is, why it is important, and why we should learn it even when languages like Python, Java, and JavaScript already exist.<br>Now it's time to stop talking and start doing something.<br>Today, we are going to set up C Programming on our Windows computer, install a compiler, write our first C program, and run it successfully.<br>And don't worry. You don't need a ₹1 lakh gaming laptop, 64 GB RAM, or a NASA computer to run a simple C program.<br>If your laptop can open a browser without turning into a heater, we can probably get started.<br>Let's begin!Watch the original video<br>Here is my original setup tutorial. Watch it alongside this written guide.<br>The video uses an older MinGW installation method. Below, I'll explain a recommended setup for new Windows installations and clarify the technical points that beginners often misunderstand.1. What do we need to start C Programming?<br>Before writing code, we need two things.<br>First, a code editor.<br>A code editor is where we write our code. We can use Visual Studio Code, Notepad++, or even Notepad.<br>Second, a compiler.<br>A compiler translates our C source code into a form that the computer can execute.<br>For this tutorial, we'll use GCC, which stands for GNU Compiler Collection.<br>GCC supports several programming languages, including C and C++.<br>Remember, installing VS Code does not automatically mean you have installed a C compiler. VS Code is where you write your code, while GCC compiles it.<br>Installing a code editor and expecting C to work automatically is like buying a notebook and expecting your homework to complete itself.<br>If that worked, every student would have a 10 CGPA and absolutely no idea how they got it.2. Installing C on Windows<br>We'll use MSYS2 with the UCRT64 GCC toolchain. This is a recommended approach for a fresh Windows installation.<br>Official websites:<br>MSYS2: <a href="https://www.msys2.org/?utm_source=chatgpt.com">https://www.msys2.org/</a><br>Microsoft's VS Code C/C++ setup guide: <a href="https://code.visualstudio.com/docs/cpp/config-mingw?utm_source=chatgpt.com">https://code.visualstudio.com/docs/cpp/config-mingw</a>Step 1: Download MSYS2<br>Open your browser and visit <a href="https://www.msys2.org/?utm_source=chatgpt.com">https://www.msys2.org/</a>.<br>Download the official installer and install it. Unless you have a specific reason to change it, keep the default installation folder:<br><code>C:\msys64</code><br>Please download it from the official website. Don't download random files called <code>GCC_FINAL_REAL_FIXED_2026.exe</code> from suspicious websites.<br>We're trying to become programmers, not the main character of a cybersecurity incident report.
Step 2: Open the MSYS2 UCRT64 terminal<br>Open your Windows Start menu and search for:<br><code>MSYS2 UCRT64</code><br>Launch it.<br>First, update the MSYS2 packages:<code></code>
```shell
pacman -Syu
```
<br>Follow the instructions displayed in the terminal. If it asks you to close the terminal after updating, close it, reopen the UCRT64 terminal, and follow any remaining update instructions.<br>Now install GCC and the development tools:<code></code>
[html:JTNDIS0tJTIwU0FOREJPWF9TVEFSVCUyMC0tJTNFJTBBJTNDaWZyYW1lJTIwd2lkdGglM0QlMjI5OTElMjIlMjBoZWlnaHQlM0QlMjI1NTclMjIlMjBzcmMlM0QlMjJodHRwcyUzQSUyRiUyRnd3dy55b3V0dWJlLmNvbSUyRmVtYmVkJTJGMm8yeFg0cTlJdW8lMjIlMjB0aXRsZSUzRCUyMkhvdyUyMHRvJTIwU2V0JTIwVXAlMjBHQ0MlMjBDJTIwTGFuZ3VhZ2UlMjBDb21waWxlciUyMG9uJTIwV2luZG93cyUyMGFuZCUyMExpbnV4JTIwJTdDJTIwU3RlcC1ieS1TdGVwJTIwR3VpZGUlMjIlMjBmcmFtZWJvcmRlciUzRCUyMjAlMjIlMjBhbGxvdyUzRCUyMmFjY2VsZXJvbWV0ZXIlM0IlMjBhdXRvcGxheSUzQiUyMGNsaXBib2FyZC13cml0ZSUzQiUyMGVuY3J5cHRlZC1tZWRpYSUzQiUyMGd5cm9zY29wZSUzQiUyMHBpY3R1cmUtaW4tcGljdHVyZSUzQiUyMHdlYi1zaGFyZSUyMiUyMHJlZmVycmVycG9saWN5JTNEJTIyc3RyaWN0LW9yaWdpbi13aGVuLWNyb3NzLW9yaWdpbiUyMiUyMGFsbG93ZnVsbHNjcmVlbiUzRSUzQyUyRmlmcmFtZSUzRSUwQSUzQyEtLSUyMFNBTkRCT1hfU0VQJTIwLS0lM0UlMEElMEElM0MhLS0lMjBTQU5EQk9YX1NFUCUyMC0tJTNFJTBBJTBBJTNDIS0tJTIwU0FOREJPWF9FTkQlMjAtLSUzRQ==]
```shell
pacman -S --needed base-devel mingw-w64-ucrt-x86_64-toolchain
```
<br>If it asks you to choose packages from the toolchain group, press Enter to accept the default selection. When asked to proceed, type <code>Y</code> and press Enter.<br>Wait for the installation to finish.<br>It might take a while depending on your internet connection. Don't close the terminal halfway through because you're bored. The compiler is installing, not writing a suspense thriller.Step 3: Add GCC to PATH<br>Now we need to make GCC accessible from Windows Command Prompt.<br>If you used the default MSYS2 installation location, the GCC executable folder should be:<br><code>C:\msys64\ucrt64\bin</code><br>Copy this path.<br>Then follow these steps:<br>Open the Windows Start menu.<br>Search for Edit environment variables for your account.<br>Open the settings.<br>Find the <code>Path</code> variable under your user variables.<br>Click Edit.<br>Click New.<br>Paste <code>C:\msys64\ucrt64\bin</code>.<br>Click OK to save your changes.<br>Do not delete your existing PATH entries. Simply add the new one.<br>And please don't randomly delete every entry because you saw a YouTube comment saying it fixes everything. We are installing a compiler, not speedrunning Windows repair.<br>Close any previously opened Command Prompt or terminal windows, then open a new one so it receives the updated PATH.
Step 4: Check whether GCC is installed<br>
<br>Press <code>Win + R</code>, type <code>cmd</code>, and press Enter.<br>Now run:
```shell
gcc --version
```
<br>If everything is configured correctly, you should see GCC version information.<br>The exact output will depend on the version you installed.<br>If Windows says:<br><code>'gcc' is not recognized as an internal or external command</code><br>it means Windows cannot find GCC. The compiler might not be installed properly, or its folder might be missing from PATH.<br>Check your installation and PATH entry before trying again.<br>Remember, <code>gcc --version</code> confirms that Windows can find GCC. We'll still compile a real program to test that everything works.3. Write your first C program<br>Congratulations! We've installed the compiler.<br>Now let's write some actual code.<br>Create a folder on your Desktop called:<br><code>C-Practice</code><br>Inside that folder, create a file called:<br><code>main.c</code><br>Make sure the filename really ends with <code>.c</code>, not <code>.txt</code>.<br>Windows sometimes hides file extensions by default, so you can enable View → Show → File name extensions in File Explorer to check.<br>Now open <code>main.c</code> in VS Code or your preferred text editor and write this code:
```cpp
#include <stdio.h><br><br><br><br>int main(void)<br><br>{<br><br> printf("Hello, World!\n");<br><br> return 0;<br><br>}
```
<br>Let's understand what we wrote.<code>#include <stdio.h></code><br>This includes the standard input/output header, which declares functions such as <code>printf()</code>.<code>int main(void)</code><br>This defines the main function, where execution of a normal hosted C program begins.<code>printf("Hello, World!\n");</code><br>This displays <code>Hello, World!</code> on the screen.<br>The <code>\n</code> moves the output to a new line.<code>return 0;</code><br>This indicates successful termination when the program reaches the return statement in a normal hosted environment.<br>It doesn't prevent every possible error. It simply returns a status value.Why is there a semicolon?<br>In C, most statements end with a semicolon.<br>Forget one in the wrong place, and the compiler might complain.<br>The compiler isn't angry with you. It doesn't even know you exist.<br>It simply follows the rules, unlike that one friend who still hasn't returned your ₹500.4. Compile and run your first program<br>Now we need to compile the code.<br>Open your <code>C-Practice</code> folder in VS Code. Select Terminal, then New Terminal.<br>Make sure the terminal is inside the folder containing <code>main.c</code>.<br>You can check by running:<code>dir</code><br>You should see <code>main.c</code> in the output.Step 1: Compile the program<br>Run:<code>gcc main.c -o main.exe</code><br>Here's what the command means:<br><code>gcc</code> runs the compiler.<br><code>main.c</code> is your source file.<br><code>-o main.exe</code> tells GCC to name the output program <code>main.exe</code>.<br>If compilation succeeds, GCC will usually return to the terminal without displaying an error message.<br>You should now have a new file called <code>main.exe</code>.Step 2: Run the program<br>If you're using Command Prompt, run:<code>main.exe</code><br>If you're using PowerShell, run:<code>.\main.exe</code><br>Your output should be:<code>Hello, World!</code><br>And there you go!<br>You've written, compiled, and executed your first C program.<br>Congratulations. You've made your computer display two words and a comma.<br>Microsoft might not hire you just yet, but everybody starts somewhere.5. What actually happens when we compile C code?<br>Let's understand something important.<br>When we write C code, we're writing source code that the processor cannot execute directly in its original form.<br>The compiler toolchain processes the source code and produces a program for the target system.<br>A typical GCC build involves several stages:<br>Preprocessing<br>Compilation<br>Assembly<br>Linking<br>We'll explore these stages in more detail later.<br>For now, remember this:<br>C source code → Compiler toolchain → Executable program → Output<br>Compiling is not simply changing the extension from <code>.c</code> to <code>.exe</code>.<br>Renaming a file doesn't transform its contents. Otherwise, we could rename our exam paper to <code>full_marks.pdf</code> and become toppers overnight.<br>Sadly, the education system hasn't implemented that feature.6. Common Windows problems and their solutionsProblem 1: GCC is not recognised<br>Check that GCC is installed and that the correct folder is in PATH.<br>For the default MSYS2 UCRT64 installation, that folder is:<br><code>C:\msys64\ucrt64\bin</code><br>Open a new terminal after changing PATH.
Problem 2: The compiler shows errors<br>
<br>Check your code for missing semicolons, misspelled function names, unmatched braces, or missing quotation marks.<br>For example, this code is missing a semicolon:<code>printf("Hello, World!\n")</code><br>The correct version is:<code>printf("Hello, World!\n");</code><br>Read the compiler's error message carefully. It often gives you a useful starting point.Problem 3: The program compiles but doesn't run<br>Check whether <code>main.exe</code> exists by running:<code>dir</code><br>Then run the correct filename.<br>In Command Prompt:<code>main.exe</code><br>In PowerShell:<code>.\main.exe</code><br>Also make sure you're running the executable you just compiled, not an older version left over from a previous attempt.Problem 4: Nothing appears on the screen<br>Check whether your program actually contains a <code>printf()</code> statement and whether you are running the correct executable.<br>If compilation fails, an older executable might still exist. That can make it look as though your latest code worked when you're actually running yesterday's version.<br>Always check for compiler errors before running the program.7. A quick look at Linux<br>Our main focus is Windows, but here's the basic setup for Linux users.<br>On Ubuntu, Debian, and Kali Linux, you can generally install GCC using:<code>sudo apt update
sudo apt install build-essential</code><br>Then check:<code>gcc --version</code><br>Create a file called <code>main.c</code> containing:<code>#include <stdio.h>
int main(void)
{
printf("Hello from GDR!\n");
return 0;
}</code><br>Compile it:<code>gcc main.c -o hello</code><br>Run it:<code>./hello</code><br>The output should be:<code>Hello from GDR!</code><br>Notice that we used <code>hello</code> without an extension.<br>Linux executables do not generally require a <code>.exe</code> or <code>.out</code> extension. GCC may create a file named <code>a.out</code> when you don't specify an output filename, but you can choose your own name using <code>-o</code>.<br>Windows and Linux also use different executable formats and system interfaces. A native executable built for one operating system does not automatically run as a native program on the other.8. Important corrections to my original video<br>Since this tutorial updates my original setup video, here are the important clarifications.<br>1. The Windows installation method is older. The original video uses MinGW Installation Manager. For a fresh installation, this guide recommends MSYS2 with UCRT64 GCC.<br>2. Adding GCC to PATH does not install GCC. You must install the compiler first. PATH helps Windows locate it.<br>3. <code>gcc --version</code> is only the first check. Compiling and running a real program is a better test of the complete setup.<br>4. <code>return 0;</code> does not prevent all errors. It normally indicates successful termination when reached. It does not guarantee that your program is free from bugs.<br>5. Linux does not require <code>.out</code> for executables. The filename extension is not what makes a file executable.<br>6. Compiling is not renaming. The compiler toolchain processes your source code and builds a program for the target system.<br>These corrections will help you follow the original video while learning the process accurately.9. Your first programming challenge<br>Now let's see whether you can write a small program yourself.<br>Your task is to display the following output:<code>Hello, World!
Hello from GDR!
I am learning C Programming.
My journey starts today!</code><br>Try writing the program before looking at the solution.<br>Here's one possible answer:<code>#include <stdio.h>
int main(void)
{
printf("Hello, World!\n");
printf("Hello from GDR!\n");
printf("I am learning C Programming.\n");
printf("My journey starts today!\n");
return 0;
}</code><br>Compile and run it using the steps you learned above.<br>If it works, excellent.<br>If it doesn't, don't immediately copy someone else's code. Read the error, check your work, and try to understand what went wrong.<br>Debugging is part of programming. It doesn't mean you're bad at it.