C Instalar no Windows e macOS

O Windows e o macOS não vêm com um compilador de C, mas instalar um é questão de minutos. No Windows há três caminhos: o MSYS2, que traz o mesmo gcc do guia; o WSL, um Linux de verdade dentro do Windows; e o Visual Studio, o ambiente da Microsoft. No macOS, um único comando instala as ferramentas da Apple, com uma surpresa: o gcc do Mac é, na verdade, o Clang. Nesta aula você vai escolher o seu caminho, instalar e conferir.

A ideia: um tradutor para cada país

Imagine que a Ana escreveu uma receita em português e quer que cozinheiros de três países a sigam. Ela precisa de um tradutor para cada país: a receita é a mesma, mas cada cozinheiro só entende a própria língua.

Com o C é igual. O seu ola.c é a receita. O compilador é o tradutor, que transforma o texto em instruções que um sistema entende. Windows, macOS e Linux "falam" de jeitos diferentes, e por isso cada um precisa do seu compilador. Nesta aula você instala o tradutor do seu sistema; a receita (o código das aulas) continua a mesma.

Antes de tudo: o terminal

O guia compila os programas pelo terminal (a janela de texto onde você digita comandos), porque assim você vê exatamente o que acontece. Cada sistema tem o seu:

Depois, se preferir, você pode compilar com um botão dentro de um editor (aula Editores e IDEs). Mas saber o comando ajuda a entender o que o botão faz, e a resolver os problemas quando o botão falha.

Windows

Qual caminho escolher?

Não precisa escolher um só: muita gente tem o MSYS2 e o WSL no mesmo computador.

Caminho 1: MSYS2, passo a passo

O MSYS2 é um pequeno "mundo Linux" para Windows: um terminal e um gerenciador de pacotes, o pacman (o mesmo do Arch Linux), de onde você instala o MinGW-w64, o GCC adaptado para gerar programas do Windows.

1. Entre em msys2.org e baixe o instalador (um arquivo como msys2-x86_64-20260927.exe; a data no nome muda). É preciso Windows 10 ou 11, de 64 bits.
2. Rode o instalador e aceite a pasta sugerida, C:\msys64. Clique em Avançar até o fim e depois em Concluir.
3. Abre-se um terminal chamado MSYS2 UCRT64 (se não abrir, procure por ele no menu Iniciar). UCRT64 é o "ambiente" recomendado: programas de 64 bits, usando a biblioteca do C moderna do Windows (a Universal C Runtime).
4. Nesse terminal, instale o kit completo (gcc, gdb, make e companhia):

   pacman -S mingw-w64-ucrt-x86_64-toolchain

5. O pacman pergunta quais itens do kit você quer (tecle Enter para "todos") e depois mostra a lista de pacotes e pergunta :: Proceed with installation? [Y/n] ("continuar com a instalação?"). Tecle Enter de novo.
6. Confira:

   $ gcc --version
   gcc.exe (Rev6, Built by MSYS2 project) 16.2.0
   Copyright (C) 2026 Free Software Foundation, Inc.
   ...

pacman

O gerenciador de pacotes do MSYS2.

-S

Sync: baixar e instalar.

mingw-w64-ucrt-x86_64-toolchain

O nome do pacote: o kit de ferramentas (toolchain) do MinGW-w64 (mingw-w64), para o ambiente UCRT64 (ucrt), em processadores de 64 bits (x86_64). Se quiser só o compilador, o pacote é mingw-w64-ucrt-x86_64-gcc.

Duas diferenças do MSYS2 para o Linux do guia: o make do kit se chama mingw32-make (o nome é antigo, mas ele gera programas de 64 bits normalmente), e as aulas do Nível 3 sobre processos (fork), sinais e Valgrind são coisas do Linux; para elas, use o WSL. Para atualizar tudo: pacman -Syu.

Usar o gcc fora do terminal do MSYS2

O gcc funciona dentro do terminal UCRT64. Para usá-lo também no PowerShell, no Terminal do Windows e no VS Code, acrescente a pasta dele ao PATH (a lista de pastas onde o Windows procura programas):

1. Menu Iniciar → digite variáveis de ambiente → "Editar as variáveis de ambiente para sua conta".
2. Selecione Path → Editar → Novo → digite C:\msys64\ucrt64\bin → OK em todas as janelas.
3. Feche e abra de novo o terminal (o PATH só é lido quando o terminal abre) e confira com gcc --version.

Compilar no Windows

O comando é o mesmo do guia. A diferença é que o executável ganha a extensão .exe sozinho, e, no PowerShell, você roda o programa com .\ em vez de ./:

PS C:\Users\Ana\c> gcc -std=c23 -Wall -Wextra ola.c -o ola
PS C:\Users\Ana\c> .\ola.exe
Olá, mundo!

Se em vez de Olá aparecer Olá, não se assuste: é um problema de acentos do console do Windows, e a solução está em Quando dá errado.

Caminho 2: WSL, um Linux dentro do Windows

O WSL (Windows Subsystem for Linux, "subsistema Windows para Linux") roda um Linux de verdade ao lado do Windows, sem máquina virtual para configurar. Com ele, tudo o que o guia mostra no terminal funciona igual, do primeiro programa ao Valgrind.

1. Abra o Terminal (ou PowerShell) como administrador: clique com o botão direito no menu Iniciar → "Terminal (Administrador)".
2. Digite:

   wsl --install

   Esse comando instala o WSL e o Ubuntu. Reinicie o computador quando ele pedir.
3. Depois de reiniciar, abra o Ubuntu no menu Iniciar. Na primeira vez, ele pede um nome de usuário e uma senha para o Linux (não precisam ser os do Windows).
4. Pronto: você está num terminal Ubuntu. Siga a aula Instalar no Linux: sudo apt update e sudo apt install build-essential gdb.

Os arquivos do Windows aparecem dentro do Linux em /mnt/c/ (o disco C:). Mas, para compilar mais rápido, guarde os seus programas na pasta pessoal do Linux (~/c). O VS Code abre essa pasta direto com a extensão WSL (aula Editores e IDEs).

Caminho 3: Visual Studio Community

O Visual Studio (não confunda com o VS Code, que é só um editor) é o ambiente completo da Microsoft, e a edição Community é gratuita para estudantes, uso pessoal e equipes pequenas. O compilador dele, o MSVC, foi feito pensando principalmente em C++: ele compila C, mas só ganhou suporte ao C11 e ao C17 em 2020, e o C23 ainda está chegando aos poucos. Por isso, para seguir este guia, prefira o MSYS2 ou o WSL. Se mesmo assim quiser usá-lo:

1. Baixe o instalador em visualstudio.microsoft.com (Visual Studio Community) e rode-o.
2. Na tela Cargas de trabalho, marque Desenvolvimento para desktop com C++. É ela que traz o compilador (que serve para C e para C++), as bibliotecas do Windows e o depurador.
3. Clique em Instalar. São vários gigabytes: pode demorar.
4. O Visual Studio não tem um modelo de projeto "C". Crie um Projeto Vazio (de C++), clique com o botão direito em Arquivos de Origem → Adicionar → Novo Item, e dê ao arquivo um nome terminado em .c, como ola.c. A extensão é o que faz o Visual Studio compilar como C (com .cpp, ele compila como C++).
5. Para escolher a versão do C: Projeto → Propriedades → C/C++ → Linguagem → Padrão da Linguagem C → escolha o mais recente.
6. Para compilar e rodar: Ctrl+F5 (Iniciar Sem Depuração).

O compilador também funciona no terminal: abra o Developer PowerShell for VS (instalado junto, no menu Iniciar) e use o comando cl. As opções têm outra forma (ilustrativo):

cl /std:c17 /W4 ola.c
.\ola.exe

cl

O compilador da Microsoft (de compile and link, compilar e ligar).

/std:c17

A versão do C, como o -std= do gcc. As versões novas do Visual Studio também aceitam /std:clatest, a mais nova que ele conhece.

/W4

Nível 4 de avisos: o equivalente aproximado do -Wall -Wextra.

ola.c

O arquivo. Com a extensão .c, o cl compila como C. O executável sai com o mesmo nome: ola.exe.

As mensagens de erro do MSVC são diferentes das do gcc e do Clang (têm códigos como C2143), mas dizem a mesma coisa. E ele tem uma mania que confunde quem está aprendendo: reclama de funções padrão do C, como o scanf, e sugere versões só da Microsoft (veja Quando dá errado).

macOS

No Mac, o compilador "oficial" é o Clang da Apple, que vem nas Command Line Tools (as "ferramentas de linha de comando" do Xcode). Você não precisa instalar o Xcode inteiro, que é enorme: as ferramentas bastam.

1. Command Line Tools: xcode-select --install

1. Abra o Terminal e digite:

   xcode-select --install

2. Uma janela pergunta se você quer instalar as ferramentas de linha de comando. Clique em Instalar e aceite a licença. O download leva alguns minutos.
3. Confira:

   % clang --version
   Apple clang version 17.0.0 (clang-1700.3.19.1)
   Target: arm64-apple-darwin25.0.0
   Thread model: posix
   InstalledDir: /Library/Developer/CommandLineTools/usr/bin

O arm64 na linha Target indica um Mac com chip Apple (M1, M2, M3…); num Mac antigo, com Intel, aparece x86_64. O % no começo da linha é o prompt do Terminal do macOS (o shell zsh), no papel do $ do Linux. As ferramentas também trazem o make e o depurador lldb.

No Mac, o gcc é o Clang disfarçado

As Command Line Tools também instalam um comando chamado gcc. Mas veja o que ele responde (ilustrativo):

% gcc --version
Apple clang version 17.0.0 (clang-1700.3.19.1)
Target: arm64-apple-darwin25.0.0
Thread model: posix
InstalledDir: /Library/Developer/CommandLineTools/usr/bin

É a mesma resposta do clang: no Mac, gcc é só um atalho para o Clang da Apple, mantido para que scripts e Makefiles antigos que chamam gcc continuem funcionando. Para o guia, isso não é problema: as opções principais são as mesmas, e você pode digitar os comandos das aulas como estão. Só não estranhe se as mensagens de erro no seu Mac se parecerem mais com as do editor do guia (que também usa o Clang) do que com as do terminal da Ana. Compile e rode exatamente como no Linux:

% gcc -std=c23 -Wall -Wextra ola.c -o ola
% ./ola
Olá, mundo!

Se o seu Apple clang for mais antigo e reclamar de -std=c23, use -std=c2x, o nome antigo da mesma versão (aula Versões do C).

2. Opcional: o GCC pelo Homebrew

Se você quiser o mesmo compilador do guia (o GCC de verdade), instale-o pelo Homebrew, o gerenciador de pacotes mais usado no Mac:

1. Instale o Homebrew, se ainda não tiver, com o comando que está na página brew.sh (copie de lá; ele começa com /bin/bash -c "$(curl -fsSL …)"). No fim, o instalador mostra dois ou três comandos para colar no Terminal: cole-os, eles colocam o brew no PATH.
2. Instale o GCC:

   brew install gcc

3. O Homebrew não ocupa o nome gcc (que é o Clang da Apple): o GCC vem com o número da versão no nome (ilustrativo):

   % gcc-16 --version
   gcc-16 (Homebrew GCC 16.2.0) 16.2.0
   ...
   % gcc-16 -std=c23 -Wall -Wextra ola.c -o ola
   % ./ola
   Olá, mundo!

Nos comandos do guia, troque gcc por gcc-16 (ou pelo número que o seu Homebrew instalou). Para atualizar: brew upgrade gcc.

Testando: o mesmo programa nos três sistemas

Seja qual for o caminho, o teste é o mesmo: o ola.c e o teste23.c da aula Instalar no Linux. Os comandos lado a lado:

Um detalhe importante: o executável de um sistema não roda no outro. O ola.exe do Windows não abre no Mac, e o ola do Linux não abre no Windows. O código-fonte é o mesmo; o programa precisa ser compilado em cada sistema (a aula Como o C Vira Programa explica por quê).

Enquanto a instalação não termina, rode o programa abaixo no editor do guia. Ele usa o pré-processador para descobrir para qual sistema foi compilado: cada compilador define um nome diferente (_WIN32 no Windows, __APPLE__ no Mac, __linux__ no Linux), e o #if escolhe a linha certa antes mesmo da compilação (aula Compilação Condicional).

#include <stdio.h>

int main(void) {
#if defined(_WIN32)
    printf("Compilado para: Windows\n");
#elif defined(__APPLE__)
    printf("Compilado para: macOS\n");
#elif defined(__linux__)
    printf("Compilado para: Linux\n");
#elif defined(__wasi__)
    printf("Compilado para: WebAssembly (o editor do guia)\n");
#else
    printf("Compilado para: outro sistema\n");
#endif
    return 0;
}

No terminal da Ana, com o gcc, o mesmo programa responde:

$ gcc -std=c23 -Wall -Wextra sistema.c -o sistema
$ ./sistema
Compilado para: Linux

Quando dá errado

As mensagens abaixo são as que aparecem nos sistemas configurados em português; o texto exato pode variar com a versão (ilustrativo).

error C4996: 'scanf': This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.

Referência

Exercícios

Missão final: pronto para o Nível 1

Sistema: Windows
Compilador: gcc do MSYS2

#include <stdio.h>

int main(void) {
    printf("Sistema: ???\n");
    printf("Compilador: ???\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    printf("Sistema: Windows\n");
    printf("Compilador: gcc do MSYS2\n");
    return 0;
}

Resumo

• Windows, recomendado: MSYS2 + pacman -S mingw-w64-ucrt-x86_64-toolchain, no terminal UCRT64; para usar no PowerShell e no VS Code, coloque C:\msys64\ucrt64\bin no PATH.
• Windows, igual ao guia: wsl --install, e depois a aula do Linux. É o melhor para o Nível 3 (fork, sinais, Valgrind).
• Windows, Visual Studio: funciona para C (arquivos .c, cl /std:c17), mas o MSVC é pensado para C++ e reclama de funções padrão como o scanf.
• macOS: xcode-select --install traz o clang, o make, o lldb e um gcc que é o Clang disfarçado; brew install gcc traz o GCC de verdade como gcc-16.
• O comando de compilação é o mesmo em todo lugar; o executável de um sistema não roda no outro.
• Acentos virando Olá no Windows: chcp 65001.
• Próximo passo: escolher onde escrever o código, em Editores e IDEs.