Come installare e usare Git su Windows con GitHub

Fabrizio Cannatelli 31 Luglio 2026

Git è uno dei sistemi di controllo delle versioni più utilizzati per gestire codice, documenti e progetti software. Permette di registrare ogni modifica effettuata sui file, confrontare versioni differenti, recuperare contenuti precedenti e collaborare con altre persone senza rischiare di sovrascrivere il lavoro altrui.

Su Windows Git non è normalmente disponibile come comando preinstallato e deve quindi essere scaricato e configurato. In questa guida vedremo come installare Git su Windows, collegarlo a un repository GitHub, creare e modificare file, effettuare commit, usare i comandi push, pull e fetch, risolvere conflitti e gestire i branch.

In breve: scarica Git for Windows, completa l’installazione mantenendo le impostazioni consigliate, configura nome ed email, clona il repository GitHub e utilizza i comandi git add, git commit, git pull e git push per sincronizzare il tuo lavoro.

Scopri anche: Coding per bambini: 7 siti per programmare giocando

Indice

Che cos’è Git e a cosa serve

Git è un sistema distribuito per il controllo delle versioni. Il programma registra le modifiche apportate ai file di un progetto e permette di conservare una cronologia completa del lavoro svolto.

Grazie a Git puoi:

salvare diverse versioni dello stesso progetto;
controllare quali file sono stati modificati;
ripristinare una versione precedente;
lavorare su nuove funzioni senza alterare il progetto principale;
collaborare con più persone;
unire le modifiche realizzate da sviluppatori differenti;
sincronizzare il progetto con servizi online come GitHub.

Git può essere utilizzato interamente sul computer, anche senza GitHub. GitHub è invece un servizio online che ospita i repository Git e facilita la condivisione e la collaborazione.

Come installare Git su Windows

Per iniziare devi scaricare Git for Windows dal sito ufficiale. L’installazione comprende Git Bash, il terminale attraverso cui puoi eseguire i comandi Git in un ambiente simile a quello disponibile su Linux.

Apri il sito ufficiale di Git.
Accedi alla sezione dedicata al download per Windows. Esiste anche la versione Portable.
Scarica la versione adatta al tuo sistema, generalmente quella a 64 bit.
Al termine del download, apri il file di installazione.
Conferma l’esecuzione se Windows mostra una richiesta di sicurezza.

In alternativa, se sul computer utilizzi il gestore di pacchetti Winget, puoi aprire il Prompt dei comandi di Windows come amministratore ed eseguire: winget install –id Git.Git -e –source winget

Guida ai file batch: cosa sono, come crearli e usarli su Windows

Come configurare l’installazione di Git

Durante l’installazione vengono mostrate diverse schermate. Per un utilizzo comune puoi mantenere quasi tutte le impostazioni predefinite, modificando soltanto le opzioni che conosci e che risultano necessarie per il tuo ambiente di lavoro.

Selezione dei componenti

Nella schermata Select Components lascia selezionati i componenti predefiniti. Puoi aggiungere le icone sul desktop, l’integrazione con Esplora file o altre funzioni facoltative, ma non sono indispensabili per usare Git.

Scelta dell’editor predefinito

Git utilizza un editor di testo per scrivere messaggi di commit e completare alcune operazioni. L’installazione può proporre Vim, ma per un principiante questo editor potrebbe risultare poco intuitivo.

Se disponibile, scegli un programma che conosci già, come:

Visual Studio Code;
Notepad++;
Nano;
un altro editor compatibile.

Puoi comunque evitare l’apertura dell’editor inserendo direttamente il messaggio del commit con l’opzione -m, come vedremo più avanti.

Configurazione del ramo iniziale

Durante l’installazione potrebbe essere richiesto quale nome utilizzare per il ramo iniziale dei nuovi repository. Puoi scegliere main, che è anche il nome usato normalmente dai nuovi repository creati su GitHub.

Configurazione della variabile PATH

Nella schermata relativa al PATH è consigliabile mantenere l’opzione che consente di utilizzare Git dalla riga di comando e anche da programmi esterni. In questo modo potrai eseguire i comandi da:

Git Bash;
Prompt dei comandi;
PowerShell;
editor e ambienti di sviluppo compatibili.

Scelta del programma SSH

Quando viene richiesta la configurazione SSH, puoi lasciare selezionata l’opzione predefinita relativa a OpenSSH. Il protocollo SSH può essere usato per collegarsi ai repository remoti senza inserire continuamente le credenziali.

Trasporto HTTPS

Nella schermata relativa al trasporto HTTPS puoi mantenere l’utilizzo della libreria OpenSSL, salvo diverse indicazioni previste dalla tua azienda o dal tuo ambiente informatico.

Conversione dei caratteri di fine riga

Windows e i sistemi Unix utilizzano convenzioni differenti per i caratteri di fine riga. Per molti utenti Windows è adatta l’opzione che esegue il checkout con fine riga in stile Windows e registra i commit con fine riga in stile Unix. Questa configurazione aiuta a ridurre i problemi quando uno stesso progetto viene modificato da computer con sistemi operativi differenti.

Terminale per Git Bash

Per Git Bash puoi lasciare selezionato MinTTY, il terminale predefinito di MSYS2. Offre un’interfaccia comoda per eseguire i comandi e visualizzare i risultati.

Opzioni aggiuntive

Nella schermata delle opzioni extra puoi mantenere le impostazioni suggerite. Le funzioni relative ai collegamenti simbolici vanno attivate soltanto quando sono realmente necessarie e quando Windows dispone delle autorizzazioni richieste. Premi infine Install e attendi il completamento della procedura. Puoi lasciare selezionata l’opzione per avviare subito Git Bash.

Come verificare se Git è installato

Apri Git Bash, il Prompt dei comandi o PowerShell e digita:

git --version

Se l’installazione è avvenuta correttamente, verrà mostrato il numero della versione installata. Se invece compare un messaggio che indica che il comando non è riconosciuto, riavvia il terminale o il computer. Se il problema continua, ripeti l’installazione controllando che Git venga aggiunto alla variabile PATH.

Git Bash o interfaccia grafica: quale usare?

Git può essere gestito tramite riga di comando oppure attraverso programmi dotati di interfaccia grafica. Per imparare il funzionamento del sistema è utile conoscere almeno i comandi principali.

Non devi modificare il codice dal terminale: puoi continuare a usare l’editor o l’ambiente di sviluppo che preferisci. Git Bash serve principalmente per controllare lo stato del progetto, creare commit, sincronizzare repository e gestire i branch.

Le interfacce grafiche possono rendere più semplici alcune attività, ma conoscere i comandi consente di capire meglio cosa sta accadendo e di seguire più facilmente guide e documentazioni tecniche.

Come configurare nome ed email in Git

Prima di creare i primi commit devi indicare il nome e l’indirizzo email che Git assocerà alle modifiche. Configura il nome con il seguente comando:

git config --global user.name "Il tuo nome"

Inserisci quindi l’indirizzo email:

git config --global user.email "tuoindirizzo@example.com"

L’opzione --global applica queste informazioni a tutti i repository utilizzati dal tuo account Windows.

Per controllare la configurazione puoi eseguire:

git config --global --list

Il nome configurato non deve necessariamente coincidere con il nome utente di GitHub. Per associare correttamente i commit al profilo GitHub, utilizza però un indirizzo email verificato nel tuo account oppure l’indirizzo privato fornito dalla piattaforma.

Come collegare Git a un repository GitHub

In questa guida utilizziamo GitHub come servizio per ospitare il repository remoto. Prima di continuare devi avere un account GitHub e un repository già creato. Un repository remoto è la copia del progetto conservata online. La copia presente sul computer viene invece chiamata repository locale.

Come clonare un repository GitHub

La clonazione scarica sul computer una copia completa del repository, comprese la cronologia e le informazioni necessarie per sincronizzare le modifiche.

Apri il repository su GitHub.
Premi il pulsante Code.
Scegli il protocollo HTTPS oppure SSH.
Copia l’indirizzo del repository.
Apri Git Bash o il terminale.
Raggiungi la cartella nella quale vuoi conservare il progetto.

Per spostarti in una cartella puoi usare il comando cd:

cd "C:\Percorso\Della\Cartella"

Esegui quindi:

git clone <URL-del-repository>

Esempio:

git clone https://github.com/nomeutente/progetto.git

Git creerà una nuova cartella con il nome del repository. Entra nella cartella con:

cd progetto

Come controllare il repository remoto

Per visualizzare i repository remoti collegati al progetto, esegui:

git remote

Normalmente vedrai il nome:

origin

origin è l’alias assegnato da Git al repository remoto dal quale hai effettuato la clonazione.

Per visualizzare anche gli indirizzi utilizzati per il download e l’invio delle modifiche, esegui:

git remote -v

Dovresti vedere due righe: una associata al recupero dei dati, indicata con fetch, e una relativa all’invio, indicata con push.

Guida al registro di sistema di Windows: cosa sapere e come usarlo

Come autenticarsi su GitHub da Windows

Quando utilizzi un repository privato o provi a inviare modifiche, GitHub deve verificare la tua identità. Con un indirizzo HTTPS, Git for Windows può utilizzare Git Credential Manager. Al primo accesso potrebbe aprirsi una finestra del browser nella quale dovrai accedere al tuo account GitHub e autorizzare l’operazione.

Se viene richiesto di inserire manualmente username e password, la normale password dell’account GitHub non deve essere utilizzata per le operazioni Git tramite HTTPS. Al suo posto occorre inserire un token di accesso personale oppure configurare un metodo di autenticazione supportato.

In alternativa puoi collegarti tramite SSH, generando una coppia di chiavi e registrando la chiave pubblica nel tuo account GitHub.

Come lavorare nel repository locale

Dopo aver clonato il progetto puoi creare nuovi file o modificare quelli esistenti usando qualsiasi editor di testo o ambiente di sviluppo.

Il normale flusso di lavoro comprende queste fasi:

modifica dei file nella cartella di lavoro;
controllo delle modifiche con git status;
aggiunta dei file all’area di staging;
creazione di un commit;
invio del commit al repository remoto.

Come creare un nuovo file e pubblicarlo su GitHub

Per creare e aprire un file di testo con Blocco note da Git Bash o dal Prompt dei comandi puoi usare:

start notepad esempio.txt

Se il file non esiste, Blocco note ti chiederà di crearlo. Inserisci del testo, salva e chiudi il programma.

In Git Bash puoi anche creare prima un file vuoto con:

touch esempio.txt

Controlla ora lo stato del repository:

git status

Git mostrerà il nuovo file tra gli elementi non tracciati, indicati in inglese come untracked files.

Come aggiungere un file all’area di staging

Per iniziare a tracciare il file, utilizza:

git add esempio.txt

L’area di staging contiene le modifiche che vuoi includere nel prossimo commit. Ripetendo git status, il file dovrebbe essere mostrato tra le modifiche pronte per il commit.

Puoi rimuovere un file dall’area di staging, senza cancellarlo dal computer, con:

git restore --staged esempio.txt

Come creare un commit

Il commit registra nel repository locale un gruppo di modifiche. Ogni commit dovrebbe avere un messaggio breve ma chiaro, capace di spiegare il lavoro effettuato.

Esegui:

git commit -m "Aggiunto il primo file di esempio"

È possibile usare anche:

git commit

In questo caso Git apre l’editor configurato durante l’installazione. Se viene aperto Vim, premi i per entrare nella modalità di inserimento, scrivi il messaggio, premi Esc, digita :wq e premi Invio per salvare e uscire.

Per un principiante, l’opzione -m è generalmente più semplice.

Come inviare i file al repository remoto

Dopo aver creato il commit, le modifiche sono registrate soltanto nel repository locale. Per trasferirle su GitHub usa:

git push

Se il branch locale non è ancora associato a quello remoto, potrebbe essere necessario indicare il repository e il nome del branch:

git push -u origin main

L’opzione -u imposta il branch remoto come riferimento. Nei successivi invii sarà normalmente sufficiente eseguire git push.

Se il ramo principale del tuo progetto ha un nome differente, sostituisci main con il nome corretto.

Come visualizzare la cronologia dei commit

Per consultare la cronologia completa esegui:

git log

Per ottenere una visualizzazione più compatta puoi usare:

git log --oneline

Ogni commit è identificato da un codice univoco, chiamato hash, e contiene autore, data e messaggio.

Come modificare un file e inviare l’aggiornamento

Apri uno o più file del progetto, apporta le modifiche e salvali. Controlla quindi la situazione con:

git status

Per aggiungere tutti i file modificati e i nuovi file presenti nella cartella, utilizza:

git add .

Il punto indica la directory corrente. Puoi ottenere un risultato simile con:

git add -A

Se vuoi aggiungere soltanto determinati file, puoi specificarne i nomi oppure utilizzare un carattere jolly. Per aggiungere tutti i file di testo:

git add *.txt

Crea quindi il commit:

git commit -m "Aggiornati i file del progetto"

Infine invia le modifiche:

git push

Come rinominare file in blocco su Windows 10/11

Perché eseguire Git pull prima di un push

Quando più persone lavorano sullo stesso repository, qualcuno potrebbe aver pubblicato nuove modifiche mentre tu stavi lavorando.

Prima di inviare il tuo commit è quindi consigliabile recuperare gli aggiornamenti remoti:

git pull

Il comando scarica le modifiche dal repository remoto e le integra nel branch corrente. In questo modo la copia locale viene aggiornata prima dell’invio del tuo lavoro.

Se il repository remoto contiene modifiche che non sono presenti sul computer, il push potrebbe essere rifiutato fino a quando non avrai sincronizzato il progetto.

Differenza tra Git pull e Git fetch

I comandi git pull e git fetch recuperano entrambi informazioni dal repository remoto, ma si comportano in modo differente.

git pull scarica gli aggiornamenti e prova a integrarli nel branch sul quale stai lavorando:

git fetch, invece, scarica le informazioni remote senza modificare automaticamente i file della cartella di lavoro:

Fetch è utile quando vuoi prima controllare gli aggiornamenti e decidere successivamente come integrarli.

Per vedere tutti i branch locali e remoti dopo il fetch puoi usare:

git branch -a

Come risolvere un conflitto di merge in Git

Un conflitto si verifica quando due persone modificano la stessa parte di un file in modi incompatibili oppure quando una modifica non può essere integrata automaticamente.

Quando Git rileva un conflitto, interrompe l’unione e inserisce nel file alcuni marcatori simili ai seguenti:

<<<<<<< HEAD
modifica locale
=======
modifica remota
>>>>>>> codice-del-commit

La parte compresa tra <<<<<<< HEAD e ======= rappresenta normalmente la modifica presente nel branch corrente. La parte successiva mostra la modifica proveniente dall’altro branch o dal repository remoto.

Devi aprire il file e decidere quale contenuto conservare. Puoi:

mantenere la modifica locale;
mantenere la modifica remota;
conservare entrambe;
riscrivere manualmente la parte interessata.

Ad esempio, puoi trasformare il conflitto precedente in:

modifica locale
modifica remota

Rimuovi sempre i marcatori inseriti da Git. Nei file lunghi può essere utile cercare le stringhe HEAD, ======= e >>>>>>> per verificare che non siano rimasti altri conflitti.

Dopo aver corretto e salvato i file, esegui:

git add .

Crea quindi un nuovo commit:

git commit -m "Risolto il conflitto di merge"

Infine invia la soluzione al repository remoto:

git push

Come controllare i file in conflitto

Durante la risoluzione puoi eseguire:

git status

Git indica quali file presentano ancora conflitti e quali sono già stati risolti e aggiunti all’area di staging.

Per progetti complessi puoi utilizzare uno strumento visuale di confronto, chiamato merge tool. Il comando è:

git mergetool

Puoi configurare programmi come WinMerge o altri strumenti compatibili per confrontare graficamente le diverse versioni del file.

Che cos’è un branch Git

Un branch è una linea di sviluppo separata. Permette di modificare il progetto senza intervenire direttamente sul ramo principale.

Puoi creare un branch, ad esempio, per:

sviluppare una nuova funzione;
correggere un errore;
provare una soluzione alternativa;
lavorare su un aggiornamento che richiederà molto tempo;
evitare di rendere instabile la versione principale.

Quando il lavoro è completo, il branch può essere unito nuovamente a main.

Come creare un branch

Prima di creare un nuovo ramo, controlla di trovarti nella cartella del repository e verifica la situazione con:

git status

Il metodo moderno per creare un branch e passarvi immediatamente è:

git switch -c nome-branch

Ad esempio:

git switch -c nuova-funzione

Puoi anche usare i comandi tradizionali:

git branch nome-branch
git checkout nome-branch

Dopo il passaggio, il terminale di Git Bash può mostrare il nome del nuovo branch nel prompt.

Come vedere i branch disponibili

Per visualizzare i branch locali:

git branch

Il branch attualmente attivo viene contrassegnato da un asterisco.

Per mostrare anche i branch remoti:

git branch -a

10 strumenti per programmazione con intelligenza artificiale

Come pubblicare un branch su GitHub

Un nuovo branch creato sul computer rimane locale fino a quando non viene inviato al repository remoto.

Per pubblicarlo esegui:

git push --set-upstream origin nome-branch

Puoi utilizzare anche la forma abbreviata:

git push -u origin nome-branch

Dopo aver impostato il collegamento sarà normalmente sufficiente usare git push e git pull.

Come cambiare branch

Per passare a un branch esistente usa:

git switch nome-branch

Il comando tradizionale equivalente è:

git checkout nome-branch

Per tornare al ramo principale:

git switch main

Oppure:

git checkout main

Prima di cambiare branch è consigliabile salvare o registrare le modifiche in corso. Git può impedire il passaggio quando l’operazione rischia di sovrascrivere modifiche locali non salvate.

Come unire un branch al ramo principale

Dopo aver completato e verificato il lavoro puoi integrare il branch nel ramo principale.

Passa prima a main:

git switch main

Aggiorna il branch principale:

git pull

Esegui quindi il merge:

git merge nome-branch

Se non vengono rilevati conflitti, Git integra le modifiche. In alcuni casi il merge genera automaticamente un commit; in altri casi può essere necessario crearne uno manualmente.

Invia infine il risultato:

git push

Se durante l’unione compare un conflitto, correggi i file, aggiungili all’area di staging e completa il commit prima di eseguire il push.

Come eliminare un branch locale

Dopo aver completato il merge, puoi eliminare il ramo locale con:

git branch -d nome-branch

L’opzione -d evita normalmente di eliminare un branch che contiene modifiche non ancora unite.

Per forzare l’eliminazione puoi usare:

git branch -D nome-branch

Usa questa seconda opzione con attenzione, perché potresti perdere commit non integrati altrove.

Come eliminare un branch remoto

Per rimuovere da GitHub un branch remoto esegui:

git push origin --delete nome-branch

L’eliminazione del branch remoto non elimina automaticamente l’eventuale copia locale. Allo stesso modo, cancellare il branch locale non rimuove quello pubblicato su GitHub.

Comandi Git principali per Windows

Questa tabella riassume i comandi utilizzati più frequentemente.

Comando	Funzione
`git --version`	Mostra la versione installata.
`git clone URL`	Clona un repository remoto.
`git status`	Mostra lo stato dei file.
`git add file`	Aggiunge un file all’area di staging.
`git add .`	Aggiunge le modifiche della cartella corrente.
`git commit -m "Messaggio"`	Registra le modifiche nel repository locale.
`git push`	Invia i commit al repository remoto.
`git pull`	Scarica e integra gli aggiornamenti remoti.
`git fetch`	Scarica gli aggiornamenti senza integrarli.
`git log --oneline`	Mostra una cronologia sintetica dei commit.
`git remote -v`	Mostra gli indirizzi dei repository remoti.
`git branch`	Elenca i branch locali.
`git switch -c nome`	Crea un branch e passa al nuovo ramo.
`git merge nome`	Unisce un branch a quello corrente.

Errori comuni durante l’utilizzo di Git

Git non è riconosciuto come comando

Chiudi e riapri il terminale. Se il problema continua, reinstalla Git verificando che venga aggiunto alla variabile PATH.

Il push viene rifiutato

Il repository remoto potrebbe contenere modifiche assenti sul computer. Esegui prima:

git pull

Risolvi gli eventuali conflitti e riprova il push.

GitHub non accetta la password

Per le operazioni Git tramite HTTPS non usare la normale password dell’account. Accedi tramite Git Credential Manager, browser o token di accesso personale.

Il file non compare nel commit

Controlla lo stato con git status e verifica di aver eseguito git add. Controlla inoltre che il file non sia escluso da un documento .gitignore.

Git apre Vim e non riesco a uscire

Premi Esc, digita :q! e premi Invio per uscire senza salvare. Per salvare e uscire, usa :wq.

Il branch main non esiste

Il repository potrebbe utilizzare un nome differente, ad esempio master. Esegui git branch per verificare il nome del ramo locale oppure git branch -a per vedere anche quelli remoti.

Conclusioni

Installare Git su Windows permette di gestire in modo ordinato progetti locali e repository ospitati su GitHub. Dopo la configurazione iniziale, il flusso di lavoro quotidiano si basa soprattutto su pochi comandi: git status, git add, git commit, git pull e git push.

Quando il progetto cresce, i branch consentono di sviluppare nuove funzioni separatamente, mentre pull, fetch e merge permettono di coordinare il lavoro con altri collaboratori. È normale incontrare qualche conflitto: Git segnala i file coinvolti e consente di scegliere manualmente quali modifiche conservare.

Prima di inviare nuovi commit, controlla sempre lo stato del repository e recupera gli aggiornamenti pubblicati dagli altri membri del gruppo. Questa semplice abitudine riduce gli errori e rende più sicura la collaborazione.

Il consiglio di Informarea.it

Imparare a usare Git tramite Git Bash può sembrare complicato all’inizio, ma evita di affidarti esclusivamente alle interfacce grafiche: conoscere almeno i comandi base ti aiuta a comprendere meglio cosa succede nel progetto e a gestire con sicurezza problemi come i conflitti di merge. Un errore comune è dimenticare di eseguire git pull prima di un push, cosa che può causare rifiuti dell’invio e perdita di tempo. Ti consigliamo quindi di abituarti a sincronizzare sempre il repository locale con quello remoto prima di caricare modifiche, mantenendo così il lavoro aggiornato e riducendo i rischi di errori nella collaborazione.