Skydda ditt kodprojekt

En säker strategi

3–2–1-regeln

Ha helst tre kopior av projektet, på minst två olika typer av lagring, varav en kopia finns på en annan plats. För ett gymnasiearbete kan det vara arbetskopian, ett privat GitHub-repository och en daterad ZIP-fil i molnlagring.

Innan du börjar

1. Hitta projektets rotmapp. För Unity är det mappen som innehåller Assets, Packages och ProjectSettings. För Godot är det mappen med project.godot. För webb är det oftast mappen med index.html eller package.json.
2. Stäng av automatisk molnsynkning av arbetsmappen. Flytta projektet till en vanlig lokal mapp om det ligger direkt i Drive, Dropbox eller OneDrive.
3. Kontrollera hemligheter. API-nycklar, lösenord, tokens, privata certifikat och filer som .env ska inte publiceras.
4. Välj rätt .gitignore innan första commit. Då slipper du ladda upp cache, byggen och tusentals genererade filer.
5. Bestäm ansvar i gruppen. Alla ska använda egna GitHub-konton. Dela repository via Collaborators – dela aldrig lösenord.

GitHub Desktop – steg för steg

1. Installera och logga in. Hämta GitHub Desktop, skapa ett GitHub-konto och aktivera gärna tvåfaktorsautentisering.
2. Skapa .gitignore. Lägg filen i projektets rotmapp och använd mallen för din projekttyp längre ner på sidan. Filnamnet ska vara exakt .gitignore, utan .txt.
3. Lägg till projektet. Välj File → Add Local Repository… och peka på rotmappen. Om mappen inte är ett Git-repository väljer du länken för att skapa ett repository där.
4. Kontrollera listan Changes. Ser du Library, node_modules, lösenord eller tusentals cachefiler? Avbryt och rätta .gitignore innan du fortsätter.
5. Gör första commit. Skriv exempelvis Första fungerande versionen i Summary och välj Commit to main.
6. Publicera. Välj Publish repository. Markera Keep this code private om projektet inte ska vara offentligt.
7. Kontrollera på webben. Öppna repositoryt på GitHub. Kontrollera att källkod och viktiga projektmappar finns – och att cache, hemligheter och byggmappar saknas.

Alternativ: terminalen

Kör kommandona i projektets rotmapp. Skapa först ett tomt repository på GitHub och ersätt webbadressen nedan.

git init
git add .
git status
git commit -m "Första fungerande versionen"
git branch -M main
git remote add origin https://github.com/ANVANDARE/PROJEKT.git
git push -u origin main

Om Git frågar efter identitet ställer du in ditt eget namn och den e-postadress som hör till GitHub-kontot:

git config --global user.name "Förnamn Efternamn"
git config --global user.email "din-epost@example.com"

Rätt .gitignore

En .gitignore talar om vad Git inte ska spara. Den ska utesluta sådant som kan återskapas, men aldrig projektets unika källkod, scener, inställningar eller originalgrafik. GitHubs färdiga mallar är säkrast när de finns för din teknik.

Unity

Versionshantera normalt Assets/, Packages/, ProjectSettings/ och alla tillhörande .meta-filer. En förlorad .meta-fil kan bryta referenser mellan objekt. Ignorera däremot genererad cache och exporterade byggen.

/[Ll]ibrary/
/[Tt]emp/
/[Oo]bj/
/[Bb]uild/
/[Bb]uilds/
/[Ll]ogs/
/[Uu]ser[Ss]ettings/
/[Mm]emoryCaptures/
/[Rr]ecordings/
/.vs/
/.gradle/
*.csproj
*.unityproj
*.sln
*.suo
*.user
*.userprefs
*.pidb
*.booproj
*.svd
*.pdb
*.mdb
*.opendb
*.VC.db
*.apk
*.aab
*.app
*.unitypackage
sysinfo.txt

I Unity ska Version Control Mode vara Visible Meta Files (standard i nyare Unity). Välj även textbaserad serialisering, Asset Serialization → Force Text, så att scener och andra resurser blir lättare att jämföra och sammanfoga. Använd gärna den kompletta, aktuella Unity-mallen från GitHub.

Godot

Versionshantera bland annat project.godot, skript, scener, resurser och originalfiler. För Godot 4 kan du använda:

# Godot 4 – importerad cache
.godot/

# Godot 3 och äldre projekt
.import/

# Genererade eller tillfälliga filer
.mono/
data_*/
mono_crash.*.json
*.translation
*.tmp

# Äldre exportfiler och hemliga uppgifter
export.cfg
export_credentials.cfg

Godot 4.1 och senare: export_presets.cfg kan normalt versionshanteras och gör det lättare att återskapa exporter. Hemliga exportuppgifter ligger i .godot/export_credentials.cfg, som redan utesluts när .godot/ ignoreras. Godot 3 och 4.0: exportinställningar kan innehålla känsliga uppgifter; kontrollera dem noga eller ignorera export_presets.cfg. Se den aktuella Godot-mallen från GitHub.

Webbprojekt

Vanlig HTML, CSS, JavaScript och bilder ska sparas. Paket kan installeras igen från package.json och låsfilen, så node_modules ska inte med. Spara package-lock.json, pnpm-lock.yaml eller yarn.lock.

node_modules/
dist/
build/
.next/
.nuxt/
.svelte-kit/
.vite/
coverage/
.cache/

# Lokala inställningar och hemligheter
.env
.env.*
!.env.example

# Operativsystem och editor
.DS_Store
Thumbs.db
.vscode/
.idea/

Ignorera bara dist/ eller build/ om de verkligen genereras från källkoden. En enkel statisk webbplats kan bestå av just de filer som ska publiceras. Spara en anonym .env.example med variabelnamn men utan riktiga värden.

Andra kodprojekt

Utgå från en aktuell mall i GitHubs samling av .gitignore-filer. Läs alltid mallen – kopiera inte regler som du inte förstår.

Stora filer och Git LFS

GitHub blockerar vanliga Git-filer på 100 MiB eller mer och rekommenderar Git LFS för stora binära filer. LFS passar exempelvis .psd, .blend, .fbx, stora ljudfiler, videor och högupplösta texturer. Det har egna lagrings- och trafikgränser, så lägg inte cache eller färdiga byggen där i onödan.

git lfs install
git lfs track "*.psd"
git lfs track "*.fbx"
git lfs track "*.blend"
git lfs track "*.wav"
git add .gitattributes
git add .
git commit -m "Lägg till Git LFS för stora filer"
git push

Filen .gitattributes måste committas så att alla i gruppen använder samma regler. Alla som klonar projektet behöver Git LFS för att få själva filerna och inte bara små pekarfiler.

Daglig rutin – ensam eller i grupp

1. Hämta först. Gör Fetch origin och Pull innan du börjar. Stäng gärna Unity eller Godot innan större hämtningar eller byte av branch.
2. Arbeta i små steg. Spara fungerande ändringar ofta. I Unity bör gruppen undvika att flera personer ändrar samma scen eller prefab samtidigt.
3. Kontrollera Changes. Läs vilka filer som ska med. Lägg aldrig till en hemlighet bara för att få en varning att försvinna.
4. Commit med tydligt meddelande. Skriv vad som blev klart, exempelvis Lägg till poängräkning och restart-knapp.
5. Push innan du lämnar datorn. Kontrollera att GitHub Desktop visar att allt är uppdaterat och att committen syns på GitHub.
6. Skriv i loggboken. Notera vad du gjorde, problem, tester och gärna länken eller id-numret till committen.

Vid en konflikt

Gör inte en ny kopia av hela projektmappen och fortsätt på måfå. Läs vilka filer som krockar, prata med den andra personen och välj eller kombinera rätt ändringar. Binära filer och Unity-scener är svåra att slå ihop – arbetsfördelning förebygger problemet. Ta en ZIP-kopia innan du gör en osäker konflikthantering.

Google Drive – endast som manuell backup

1. Spara och stäng programmen. Avsluta Unity, Godot, utvecklingsservern och kodeditorn. Vänta tills alla skrivningar är klara.
2. Kontrollera projektet. Öppna rätt rotmapp och se till att de senaste filerna finns där.
3. Skapa en ZIP-fil. Döp den med datum och version, exempelvis MittSpel_2026-09-22_v07.zip. För snabbare Unity-kopior kan Library, Temp, Logs och Obj uteslutas; Unity återskapar dem.
4. Ladda upp ZIP-filen. Lägg den i Google Drive, OneDrive, Dropbox eller på ett externt minne – inte bara bredvid originalmappen på samma disk.
5. Behåll flera datum. Spara exempelvis veckans fyra senaste kopior och en kopia per viktig milstolpe.
6. Testa filen. Kontrollera att den går att ladda ner, packa upp och öppna från en annan mapp.

En ZIP-kopia är en ögonblicksbild, inte ett bra samarbetsverktyg. Skicka inte olika ZIP-versioner fram och tillbaka i en grupp; använd GitHub och en tydlig arbetsfördelning.

Skydda lösenord och personuppgifter

• Commit aldrig API-nycklar, databasanvändare, lösenord, privata certifikat eller åtkomsttokens.
• Lägg lokala hemligheter i en ignorerad .env-fil eller i operativsystemets hemlighetshantering.
• Spara en .env.example med exempelvärden så att projektet går att konfigurera efter kloning.
• Kontrollera även skärmbilder, loggar, databaser och testdata efter personuppgifter.
• Om en hemlighet har pushats: behandla den som avslöjad. Spärra eller rotera den omedelbart. Att bara radera filen i en senare commit tar inte bort den ur historiken.

Så vet du att backupen fungerar

En backup är inte verifierad förrän projektet har återställts. Testa efter första publiceringen och därefter vid viktiga milstolpar:

1. Klona till en ny, tom mapp. I GitHub Desktop väljer du File → Clone repository…. Kopiera inte filer från din gamla arbetsmapp.
2. Återskapa beroenden. Unity och Godot importerar cache på nytt. Webbprojekt kör exempelvis npm install. Pythonprojekt skapar en ny virtuell miljö och installerar beroenden.
3. Öppna och kör. Kontrollera huvudscener, bilder, ljud, paket och inställningar. Bygg eller exportera projektet om det är en viktig milstolpe.
4. Dokumentera det som saknas. Uppdatera README.md, beroendefiler, .gitignore eller LFS-regler och gör sedan commit och push.

Projektets README.md bör förklara

• vad projektet är och hur det startas,
• program- och motorversion, till exempel exakt Unity- eller Godot-version,
• vilka paket, SDK:er eller andra beroenden som behövs,
• vilka miljövariabler som ska finnas – men inte deras hemliga värden,
• hur projektet byggs, exporteras och testas.

Vanliga problem

Kontrollista före dagens slut

• Projektet öppnas och den viktigaste funktionen fungerar.
• Changes innehåller inga cachefiler, hemligheter eller onödiga byggen.
• Alla färdiga ändringar är committade med ett begripligt meddelande.
• Senaste committen är pushad och syns på GitHub.
• Gruppen vet vem som arbetar med vilka filer eller scener.
• En ny daterad ZIP-backup finns efter en viktig milstolpe.
• Projektet har provklonats och återställts sedan senaste större ändringen.

Officiella guider och mallar

• GitHub DesktopLägg till och publicera ett befintligt projekt
• GitHubGit LFS och stora filer
• GitHubAktuella .gitignore-mallar
• GodotVersionshantering i Godot
• UnityInställningar för versionshantering
• GitFörsta konfigurationen av Git