diff --git a/sites/he/glossary/add.md b/sites/he/glossary/add.md
new file mode 100644
index 00000000..44aa7208
--- /dev/null
+++ b/sites/he/glossary/add.md
@@ -0,0 +1,85 @@
+ # Add (הוספה)
+
+**הגדרה קצרה:** פקודה ב-Git שמעבירה קבצים או שינויים מאזור העבודה (working directory) לאזור ההכנה (staging area), כדי להכין אותם ל-commit.
+
+## הסבר מורחב
+
+`Add` (הוספה) היא הפקודה שמעבירה שינויים מאזור העבודה לאזור ההכנה. זה השלב הראשון בתהליך ה-commit, שבו אתה בוחר איזה שינויים לכלול ב-commit הבא.
+
+**דוגמאות לשימוש נפוץ:**
+* הוספת קבצים חדשים למעקב
+* הכנת שינויים ל-commit
+* הוספת קבצים לפי סוג או מיקום
+* הוספת כל השינויים בבת אחת
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# הוספת קובץ ספציפי
+git add file.txt
+
+# הוספת כל השינויים
+git add .
+
+# הוספת קבצים לפי סיומת
+git add *.js
+git add *.py
+
+# הוספת קבצים בתיקיה
+git add src/
+
+# הוספת קבצים עם pattern
+git add "*.{js,css,html}"
+
+# הוספת קבצים אינטראקטיבית
+git add -i
+
+# הוספת קבצים עם patch
+git add -p
+
+# הוספת קבצים עם אימות
+git add --dry-run file.txt
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+
+repo = Repo('my_repo')
+
+# הוספת קובץ
+def add_file(repo, file_path):
+    repo.index.add([file_path])
+    print(f"נוסף {file_path}")
+
+# הוספת כל השינויים
+def add_all(repo):
+    repo.index.add('*')
+    print("נוספו כל השינויים")
+
+# הוספת קבצים לפי pattern
+def add_pattern(repo, pattern):
+    repo.index.add(pattern)
+    print(f"נוספו קבצים לפי {pattern}")
+
+# בדיקת מה נוסף
+def check_added(repo):
+    staged = repo.index.diff('HEAD')
+    print(f"קבצים שהוכנו: {len(staged)}")
+    for diff in staged:
+        print(f"  {diff.a_path}")
+
+add_file(repo, "new_file.txt")
+check_added(repo)
+```
+
+## מונחים קשורים
+
+* [Staging Area (אזור ההכנה)](./staging.md)
+* [Commit (התחייבות)](./commit.md)
+* [Status (מצב)](./status.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על git add](https://git-scm.com/docs/git-add)
\ No newline at end of file
diff --git a/sites/he/glossary/blame.md b/sites/he/glossary/blame.md
new file mode 100644
index 00000000..622bcee3
--- /dev/null
+++ b/sites/he/glossary/blame.md
@@ -0,0 +1,59 @@
+# Blame (הצגת מי שינה כל שורה)
+
+**הגדרה קצרה:** פקודה ב-Git המציגה מי שינה כל שורה בקובץ, כולל זיהוי ההתחייבות, המחבר והתאריך.
+
+## הסבר מורחב
+
+`Blame` (הצגת מי שינה כל שורה) מאפשר לך לראות מי אחראי לכל שורה בקובץ. זה שימושי למציאת מקור באגים, הבנת היסטוריית הקוד, וזיהוי מי צריך לבדוק שינוי ספציפי.
+
+**דוגמאות לשימוש נפוץ:**
+* מציאת מי הכניס באג לקוד
+* הבנת מי עבד על פיצ'ר מסוים
+* זיהוי מי צריך לבדוק שינוי
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# הצגת blame של קובץ
+git blame file.txt
+
+# הצגת blame עם מספר שורות
+git blame -L 10,20 file.txt
+
+# הצגת blame עם תאריכים
+git blame --date=short file.txt
+
+# הצגת blame עם זיהוי התחייבות
+git blame -w file.txt
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+
+repo = Repo('my_repo')
+
+# הצגת blame של קובץ
+def show_blame(repo, file_path):
+    try:
+        blame = repo.blame('HEAD', file_path)
+        for commit, lines in blame:
+            for line in lines:
+                print(f"{commit.hexsha[:8]} {commit.author.name}: {line}")
+    except Exception as e:
+        print(f"שגיאה: {e}")
+
+# דוגמה
+show_blame(repo, "main.py")
+```
+
+## מונחים קשורים
+
+* [Log (היסטוריה)](./log.md)
+* [Commit (התחייבות)](./commit.md)
+* [Diff (הבדלים)](./diff.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על git blame](https://git-scm.com/docs/git-blame) 
\ No newline at end of file
diff --git a/sites/he/glossary/branch.md b/sites/he/glossary/branch.md
new file mode 100644
index 00000000..15296fb7
--- /dev/null
+++ b/sites/he/glossary/branch.md
@@ -0,0 +1,57 @@
+# Branch (ענף)
+
+**הגדרה קצרה:** ענף הוא קו פיתוח עצמאי במאגר קוד (repository) במערכת ניהול גרסאות כמו **Git**. כל ענף מאפשר לבצע שינויים, פיתוחים או ניסויים מבלי להשפיע על הקוד הראשי (לרוב master/main).
+
+## הסבר מורחב
+
+`Branch` (ענף) הוא כלי מרכזי בעבודה עם Git. כל ענף הוא למעשה הצבעה (pointer) להיסטוריית התחייבויות (commits) נפרדת, שמאפשרת פיתוח במקביל למספר כיוונים. נהוג ליצור ענפים חדשים עבור פיצ'רים, תיקוני באגים, ניסויים או גרסאות שונות של הפרויקט. כאשר העבודה בענף מסתיימת, ניתן למזג (merge) אותו חזרה לענף הראשי או לכל ענף אחר.
+
+היתרונות העיקריים של **Branch** הם:
+* **פיתוח במקביל:** מספר מפתחים/ות יכולים לעבוד על פיצ'רים שונים מבלי להפריע זה לזו.
+* **ניסוי וטעייה:** ניתן לבדוק רעיונות חדשים מבלי לסכן את הקוד היציב.
+* **ניהול גרסאות:** מאפשר לנהל גרסאות שונות של הפרויקט (למשל, גרסת פיתוח מול גרסת ייצור).
+
+**דוגמאות לשימוש נפוץ:**
+* יצירת ענף חדש עבור פיצ'ר: `git checkout -b feature/login`
+* עבודה על תיקון באג בענף נפרד.
+* מיזוג (merge) של ענף הפיצ'ר לענף הראשי לאחר סיום הפיתוח.
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# יצירת ענף חדש ומעבר אליו
+git checkout -b feature/login
+
+# מעבר לענף קיים
+git checkout main
+
+# מחיקת ענף מקומי
+git branch -d feature/login
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+repo = Repo('my_repo')
+# יצירת ענף חדש
+new_branch = repo.create_head('feature/login')
+# מעבר לענף החדש
+new_branch.checkout()
+# מעבר לענף קיים
+repo.heads.main.checkout()
+# מחיקת ענף (דרך git)
+repo.git.branch('-d', 'feature/login')
+```
+
+## מונחים קשורים
+
+* [Repository (מאגר קוד)](./repository.md)
+* [Commit (התחייבות)](./commit.md)
+* [Merge (מיזוג)](./merge.md)
+* [Pull Request (בקשת משיכה)](./pull-request.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על Branches](https://git-scm.com/book/he/v2/%D7%91%D7%A1%D7%99%D7%A1-%D7%94-Git-%D7%A2%D7%A0%D7%A4%D7%99%D7%9D-%D7%91%D7%92%D7%99%D7%98)
+* [תיעוד GitHub על Branches](https://docs.github.com/en/get-started/quickstart/github-glossary#branch) 
\ No newline at end of file
diff --git a/sites/he/glossary/checkout.md b/sites/he/glossary/checkout.md
new file mode 100644
index 00000000..6ac1099e
--- /dev/null
+++ b/sites/he/glossary/checkout.md
@@ -0,0 +1,206 @@
+ # Checkout (מעבר)
+
+**הגדרה קצרה:** פעולה ב-Git המאפשרת לעבור בין ענפים שונים, התחייבויות שונות או קבצים ספציפיים, תוך עדכון אזור העבודה (working directory) למצב הרצוי.
+
+## הסבר מורחב
+
+`Checkout` (מעבר) הוא אחד הפקודות הבסיסיות והחשובות ביותר ב-Git. היא מאפשרת לך לעבור בין מצבים שונים במאגר:
+
+1. **מעבר לענף אחר** - שינוי הענף הפעיל
+2. **מעבר להתחייבות ספציפית** - חזרה לנקודה בהיסטוריה
+3. **מעבר לקובץ ספציפי** - שחזור קובץ לגרסה קודמת
+4. **יצירת ענף חדש** - יצירת ענף חדש ומעבר אליו
+
+היתרונות העיקריים של **Checkout** הם:
+* **גמישות:** מאפשר מעבר מהיר בין מצבים שונים במאגר.
+* **בטיחות:** שומר על שינויים לא מוכנים (אם אפשר).
+* **נוחות:** מאפשר לבדוק קוד ללא שינוי הענף הפעיל.
+* **יצירתיות:** מאפשר ליצור ענפים חדשים בקלות.
+
+**דוגמאות לשימוש נפוץ:**
+* מעבר לענף אחר כדי לעבוד על פיצ'ר חדש.
+* חזרה להתחייבות קודמת כדי לבדוק קוד.
+* יצירת ענף חדש מתוך ענף קיים.
+* שחזור קובץ לגרסה קודמת.
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# מעבר לענף קיים
+git checkout main
+git checkout develop
+git checkout feature/new-feature
+
+# יצירת ענף חדש ומעבר אליו
+git checkout -b feature/new-feature
+git checkout -b hotfix/bug-fix main
+
+# מעבר להתחייבות ספציפית
+git checkout abc1234
+git checkout HEAD~1
+
+# מעבר לקובץ ספציפי (שחזור לגרסה אחרונה)
+git checkout HEAD -- file.txt
+git checkout HEAD -- src/
+
+# מעבר לקובץ מהתחייבות ספציפית
+git checkout abc1234 -- file.txt
+
+# מעבר לענף מרוחק
+git checkout -b local-branch origin/remote-branch
+
+# מעבר לענף עם מעקב אחרי ענף מרוחק
+git checkout --track origin/feature-branch
+
+# מעבר לענף אחר עם שמירת שינויים
+git checkout -m feature-branch
+
+# מעבר לענף אחר עם stash אוטומטי
+git checkout -m feature-branch && git stash
+
+# מעבר לענף אחר עם commit אוטומטי
+git checkout -m feature-branch && git commit -m "WIP"
+
+# בדיקת ענף נוכחי
+git checkout --show-current
+
+# מעבר לענף אחר עם אימות
+git checkout --verify-signatures main
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+import os
+
+repo = Repo('my_repo')
+
+# מעבר לענף קיים
+def checkout_branch(repo, branch_name):
+    """מעבר לענף קיים"""
+    try:
+        repo.git.checkout(branch_name)
+        print(f"עברת לענף {branch_name}")
+        return True
+    except Exception as e:
+        print(f"שגיאה במעבר לענף {branch_name}: {e}")
+        return False
+
+# יצירת ענף חדש ומעבר אליו
+def create_and_checkout_branch(repo, new_branch, base_branch='HEAD'):
+    """יצירת ענף חדש ומעבר אליו"""
+    try:
+        repo.git.checkout('-b', new_branch, base_branch)
+        print(f"נוצר ענף חדש {new_branch} ועברת אליו")
+        return True
+    except Exception as e:
+        print(f"שגיאה ביצירת ענף {new_branch}: {e}")
+        return False
+
+# מעבר להתחייבות ספציפית
+def checkout_commit(repo, commit_hash):
+    """מעבר להתחייבות ספציפית"""
+    try:
+        repo.git.checkout(commit_hash)
+        print(f"עברת להתחייבות {commit_hash[:8]}")
+        return True
+    except Exception as e:
+        print(f"שגיאה במעבר להתחייבות {commit_hash}: {e}")
+        return False
+
+# שחזור קובץ לגרסה אחרונה
+def restore_file(repo, file_path):
+    """שחזור קובץ לגרסה אחרונה"""
+    try:
+        repo.git.checkout('HEAD', '--', file_path)
+        print(f"קובץ {file_path} שוחזר לגרסה אחרונה")
+        return True
+    except Exception as e:
+        print(f"שגיאה בשחזור {file_path}: {e}")
+        return False
+
+# מעבר לענף עם שמירת שינויים
+def safe_checkout(repo, branch_name):
+    """מעבר בטוח לענף עם שמירת שינויים"""
+    try:
+        # בדיקה אם יש שינויים לא מוכנים
+        if repo.is_dirty():
+            print("יש שינויים לא מוכנים, שומר כ-stash...")
+            repo.git.stash()
+            repo.git.checkout(branch_name)
+            print(f"עברת לענף {branch_name}, השינויים נשמרו ב-stash")
+        else:
+            repo.git.checkout(branch_name)
+            print(f"עברת לענף {branch_name}")
+        return True
+    except Exception as e:
+        print(f"שגיאה במעבר בטוח: {e}")
+        return False
+
+# בדיקת ענפים זמינים
+def list_branches(repo):
+    """הצגת רשימת ענפים זמינים"""
+    branches = []
+    for branch in repo.branches:
+        branches.append(branch.name)
+    
+    print("ענפים זמינים:")
+    for branch in branches:
+        if branch == repo.active_branch.name:
+            print(f"  * {branch} (נוכחי)")
+        else:
+            print(f"    {branch}")
+    
+    return branches
+
+# מעבר לענף מרוחק
+def checkout_remote_branch(repo, remote_branch):
+    """מעבר לענף מרוחק"""
+    try:
+        # יצירת ענף מקומי עם מעקב אחרי הענף המרוחק
+        local_branch = remote_branch.replace('origin/', '')
+        repo.git.checkout('-b', local_branch, remote_branch)
+        print(f"עברת לענף מרוחק {remote_branch} כענף מקומי {local_branch}")
+        return True
+    except Exception as e:
+        print(f"שגיאה במעבר לענף מרוחק {remote_branch}: {e}")
+        return False
+
+# דוגמה לשימוש
+if __name__ == "__main__":
+    # הצגת ענף נוכחי
+    current_branch = repo.active_branch.name
+    print(f"ענף נוכחי: {current_branch}")
+    
+    # הצגת ענפים זמינים
+    available_branches = list_branches(repo)
+    
+    # דוגמה: יצירת ענף חדש
+    new_feature = "feature/user-authentication"
+    if create_and_checkout_branch(repo, new_feature):
+        print(f"עובד על פיצ'ר חדש: {new_feature}")
+    
+    # דוגמה: שחזור קובץ
+    if restore_file(repo, "config.json"):
+        print("קובץ config.json שוחזר")
+    
+    # דוגמה: מעבר בטוח לענף אחר
+    if safe_checkout(repo, "main"):
+        print("חזרת לענף main")
+```
+
+## מונחים קשורים
+
+* [Branch (ענף)](./branch.md)
+* [Commit (התחייבות)](./commit.md)
+* [HEAD (ראש המאגר)](./head.md)
+* [Working Directory (אזור העבודה)](./working-directory.md)
+* [Stash (שמירה זמנית)](./stash.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על git checkout](https://git-scm.com/docs/git-checkout)
+* [Git Checkout Tutorial](https://git-scm.com/book/en/v2/Git-Branching-Basic-Branching-and-Merging)
+* [GitPython Documentation](https://gitpython.readthedocs.io/en/stable/reference.html#git.cmd.Git.checkout)
+* [Understanding Git Checkout](https://git-scm.com/book/en/v2/Git-Branching-Basic-Branching-and-Merging#_basic_branching)
\ No newline at end of file
diff --git a/sites/he/glossary/cherry-pick.md b/sites/he/glossary/cherry-pick.md
new file mode 100644
index 00000000..69e12f22
--- /dev/null
+++ b/sites/he/glossary/cherry-pick.md
@@ -0,0 +1,179 @@
+ # Cherry-pick (בחירת התחייבות ספציפית)
+
+**הגדרה קצרה:** פעולה ב-Git המאפשרת לבחור התחייבות ספציפית מענף אחד ולהעתיק אותה לענף אחר, ללא העתקת כל ההיסטוריה של הענף המקורי.
+
+## הסבר מורחב
+
+`Cherry-pick` (בחירת התחייבות ספציפית) הוא כלי שימושי ב-Git כאשר אתה רוצה להעתיק התחייבות ספציפית או מספר התחייבויות מענף אחד לענף אחר, מבלי להעתיק את כל הענף או לבצע merge מלא. זה שימושי במיוחד כאשר יש התחייבות עם תיקון או פיצ'ר שאתה רוצה להחיל על ענף אחר.
+
+היתרונות העיקריים של **Cherry-pick** הם:
+* **בחירה מדויקת:** מאפשר לבחור התחייבויות ספציפיות בלבד.
+* **גמישות:** לא צריך להעתיק את כל ההיסטוריה של הענף.
+* **תיקונים מהירים:** מאפשר להחיל תיקון על מספר ענפים.
+* **שליטה טובה:** מאפשר לשלוט בדיוק איזה שינויים להחיל.
+
+**דוגמאות לשימוש נפוץ:**
+* העתקת תיקון bug מענף develop לענף main.
+* העתקת פיצ'ר ספציפי לענף release.
+* העתקת התחייבות עם תיקון דחוף לענפים שונים.
+* בחירת התחייבויות ספציפיות מתוך branch גדול.
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# cherry-pick של התחייבות אחת
+git cherry-pick abc1234
+
+# cherry-pick של מספר התחייבויות
+git cherry-pick abc1234 def5678 ghi9012
+
+# cherry-pick של טווח התחייבויות (לא כולל הראשונה)
+git cherry-pick abc1234..def5678
+
+# cherry-pick עם המשך אוטומטי במקרה של קונפליקטים
+git cherry-pick --continue
+
+# ביטול cherry-pick
+git cherry-pick --abort
+
+# cherry-pick עם skip של התחייבות בעייתיות
+git cherry-pick --skip
+
+# cherry-pick ללא יצירת התחייבות (רק שינויים)
+git cherry-pick --no-commit abc1234
+
+# cherry-pick עם עריכת הודעת התחייבות
+git cherry-pick -e abc1234
+
+# cherry-pick עם שמירת מחבר המקור
+git cherry-pick -x abc1234
+
+# cherry-pick עם אימות חתימה
+git cherry-pick --verify-signatures abc1234
+
+# cherry-pick של התחייבות עם תיקון אוטומטי
+git cherry-pick --strategy=recursive -X theirs abc1234
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+import os
+
+repo = Repo('my_repo')
+
+# cherry-pick בסיסי
+def cherry_pick_commit(repo, commit_hash):
+    """ביצוע cherry-pick של התחייבות ספציפית"""
+    try:
+        repo.git.cherry_pick(commit_hash)
+        print(f"Cherry-pick של {commit_hash} הושלם בהצלחה")
+        return True
+    except Exception as e:
+        print(f"שגיאה ב-cherry-pick: {e}")
+        return False
+
+# cherry-pick של מספר התחייבויות
+def cherry_pick_multiple(repo, commit_hashes):
+    """ביצוע cherry-pick של מספר התחייבויות"""
+    successful_picks = []
+    failed_picks = []
+    
+    for commit_hash in commit_hashes:
+        try:
+            repo.git.cherry_pick(commit_hash)
+            successful_picks.append(commit_hash)
+            print(f"✓ Cherry-pick של {commit_hash} הושלם")
+        except Exception as e:
+            failed_picks.append(commit_hash)
+            print(f"✗ שגיאה ב-cherry-pick של {commit_hash}: {e}")
+            # ביטול cherry-pick כושל
+            try:
+                repo.git.cherry_pick('--abort')
+            except:
+                pass
+    
+    return successful_picks, failed_picks
+
+# cherry-pick עם טיפול בקונפליקטים
+def cherry_pick_with_conflict_resolution(repo, commit_hash, strategy='theirs'):
+    """ביצוע cherry-pick עם אסטרטגיה לפתרון קונפליקטים"""
+    try:
+        # ניסיון cherry-pick רגיל
+        repo.git.cherry_pick(commit_hash)
+        print(f"Cherry-pick של {commit_hash} הושלם ללא קונפליקטים")
+        return True
+    except Exception as e:
+        if "conflict" in str(e).lower():
+            print(f"קונפליקט ב-cherry-pick של {commit_hash}, מנסה לפתור...")
+            try:
+                # פתרון קונפליקטים עם אסטרטגיה
+                repo.git.cherry_pick('--strategy=recursive', f'-X{strategy}')
+                print(f"קונפליקט נפתר בהצלחה")
+                return True
+            except Exception as e2:
+                print(f"לא ניתן לפתור קונפליקט: {e2}")
+                repo.git.cherry_pick('--abort')
+                return False
+        else:
+            print(f"שגיאה אחרת: {e}")
+            return False
+
+# בדיקת התחייבויות זמינות ל-cherry-pick
+def find_commits_for_cherry_pick(repo, source_branch, target_branch):
+    """מציאת התחייבויות שניתן לבצע עליהן cherry-pick"""
+    try:
+        # מעבר לענף המקור
+        repo.git.checkout(source_branch)
+        
+        # קבלת התחייבויות שלא קיימות בענף היעד
+        commits = repo.git.log(
+            f'{target_branch}..HEAD',
+            '--oneline',
+            '--no-merges'
+        ).split('\n')
+        
+        # ניקוי רשימה
+        commits = [commit.strip() for commit in commits if commit.strip()]
+        
+        print(f"התחייבויות זמינות ל-cherry-pick מ-{source_branch} ל-{target_branch}:")
+        for i, commit in enumerate(commits, 1):
+            print(f"{i}. {commit}")
+        
+        return commits
+        
+    except Exception as e:
+        print(f"שגיאה במציאת התחייבויות: {e}")
+        return []
+
+# דוגמה לשימוש
+if __name__ == "__main__":
+    # דוגמה: cherry-pick של תיקון bug
+    bug_fix_commit = "abc1234"
+    if cherry_pick_commit(repo, bug_fix_commit):
+        print("תיקון ה-bug הוחל בהצלחה")
+    
+    # דוגמה: cherry-pick של מספר התחייבויות
+    feature_commits = ["def5678", "ghi9012", "jkl3456"]
+    successful, failed = cherry_pick_multiple(repo, feature_commits)
+    
+    print(f"\nסיכום:")
+    print(f"התחייבויות שהוחלו בהצלחה: {len(successful)}")
+    print(f"התחייבויות שנכשלו: {len(failed)}")
+```
+
+## מונחים קשורים
+
+* [Commit (התחייבות)](./commit.md)
+* [Branch (ענף)](./branch.md)
+* [Merge (מיזוג)](./merge.md)
+* [Rebase (שינוי בסיס)](./rebase.md)
+* [Conflict (קונפליקט)](./conflict.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על git cherry-pick](https://git-scm.com/docs/git-cherry-pick)
+* [Git Cherry-pick Tutorial](https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History)
+* [GitPython Documentation](https://gitpython.readthedocs.io/en/stable/reference.html#git.cmd.Git.cherry_pick)
+* [Advanced Cherry-pick Strategies](https://git-scm.com/docs/git-cherry-pick#_examples)
\ No newline at end of file
diff --git a/sites/he/glossary/clone.md b/sites/he/glossary/clone.md
new file mode 100644
index 00000000..1044e572
--- /dev/null
+++ b/sites/he/glossary/clone.md
@@ -0,0 +1,78 @@
+# Clone (שכפול)
+
+**הגדרה קצרה:** פעולה במערכת ניהול הגרסאות **Git** ובפלטפורמות כמו **GitHub**, שבה נוצרת העתקה מלאה של מאגר קוד (**repository**) מהמיקום המקורי (לרוב מהשרת) אל המחשב המקומי של המשתמש.
+
+## הסבר מורחב
+
+`Clone` (שכפול) הוא אחד הצעדים הראשונים שמבצע מפתח שרוצה לעבוד עם פרויקט קיים ב-Git. כאשר מבצעים `git clone`, נוצרת תיקיה חדשה במחשב המקומי, המכילה את כל קבצי המאגר, ההיסטוריה המלאה של השינויים, וההגדרות של המאגר המקורי (כולל כתובת ה-remote).
+
+היתרונות העיקריים של **Clone** הם:
+* **עבודה לא מקוונת:** מאפשר למפתחים לעבוד על הקוד במחשב האישי, גם ללא חיבור לאינטרנט.
+* **גישה להיסטוריה:** כל ההיסטוריה של המאגר זמינה, כולל כל הענפים והתחייבויות.
+* **שיתוף פעולה:** ניתן לבצע שינויים מקומיים, ליצור ענפים חדשים, ולדחוף אותם חזרה למאגר המקורי (אם יש הרשאות).
+
+**דוגמאות לשימוש נפוץ:**
+* כאשר רוצים להתחיל לעבוד על פרויקט קיים מהאינטרנט.
+* כאשר רוצים לבדוק קוד של פרויקט לפני שמבצעים בו שינויים.
+* כאשר רוצים לבצע שינויים ולתרום אותם חזרה באמצעות Pull Request.
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# שכפול בסיסי של מאגר קוד
+git clone https://github.com/USERNAME/REPO.git
+
+# שכפול לתיקיה ספציפית
+git clone https://github.com/USERNAME/REPO.git my_project_folder
+
+# שכפול ענף ספציפי
+git clone -b develop https://github.com/USERNAME/REPO.git
+
+# שכפול רדוד (ללא היסטוריה)
+git clone --depth 1 https://github.com/USERNAME/REPO.git
+
+# שכפול עם תת-מודולים
+git clone --recursive https://github.com/USERNAME/REPO.git
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+import os
+
+# שכפול בסיסי
+repo = Repo.clone_from('https://github.com/USERNAME/REPO.git', 'local_folder')
+
+# שכפול עם הגדרות נוספות
+repo = Repo.clone_from(
+    'https://github.com/USERNAME/REPO.git',
+    'local_folder',
+    branch='develop',        # שכפול ענף ספציפי
+    depth=1,                # שכפול רדוד
+    recursive=True          # כולל תת-מודולים
+)
+
+# בדיקת סטטוס אחרי השכפול
+print(f"Active branch: {repo.active_branch}")
+print(f"Working dir: {repo.working_dir}")
+
+# הצגת רשימת הקבצים במאגר
+for root, dirs, files in os.walk(repo.working_dir):
+    print(f"\nDirectory: {root}")
+    for file in files:
+        print(f"  {file}")
+```
+
+## מונחים קשורים
+
+* [Repository (מאגר קוד)](./repository.md)
+* [Fork (מזלג)](./fork.md)
+* [Pull Request (בקשת משיכה)](./pull-request.md)
+* [Branch (ענף)](./branch.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על git clone](https://git-scm.com/docs/git-clone)
+* [תיעוד GitHub על Cloning a repository](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository)
+* [GitPython Documentation](https://gitpython.readthedocs.io/en/stable/reference.html#git.repo.base.Repo.clone_from)
diff --git a/sites/he/glossary/commit.md b/sites/he/glossary/commit.md
new file mode 100644
index 00000000..c9910cc0
--- /dev/null
+++ b/sites/he/glossary/commit.md
@@ -0,0 +1,49 @@
+# Commit (התחייבות)
+
+**הגדרה קצרה:** התחייבות היא שמירה של שינוי (או מספר שינויים) במאגר קוד (repository) במערכת ניהול גרסאות כמו **Git**. כל Commit מתעד את מצב הקבצים ברגע מסוים, כולל הודעת תיעוד (commit message) שמסבירה את השינוי.
+
+## הסבר מורחב
+
+`Commit` (התחייבות) הוא אחד היסודות המרכזיים בעבודה עם Git. כל commit יוצר "צילום מצב" (snapshot) של כל הקבצים במאגר באותו רגע, ומוסיף אותו להיסטוריית השינויים. כל commit כולל מזהה ייחודי (hash), מחבר, תאריך, הודעת תיעוד, וקישור ל-commit הקודם (או קודמים, במקרה של merge). כך ניתן לעקוב אחרי כל שינוי, לשחזר גרסאות קודמות, ולבצע ניהול גרסאות מדויק.
+
+היתרונות העיקריים של **Commit** הם:
+* **מעקב אחר שינויים:** כל שינוי מתועד, כולל מי ביצע אותו ומתי.
+* **שחזור גרסאות:** ניתן לחזור לכל נקודה בהיסטוריה של הפרויקט.
+* **שיתוף פעולה:** מאפשר למספר מפתחים לעבוד יחד ולשלב שינויים בצורה מסודרת.
+
+**דוגמאות לשימוש נפוץ:**
+* שמירת שינוי בקוד: `git commit -m "הוספת פונקציה חדשה"`
+* תיעוד תיקון באג עם הודעה ברורה.
+* מעבר בין Commits שונים כדי לבדוק התנהגות קוד בעבר.
+
+## דוגמת קוד
+
+### פקודת Git בטרמינל
+```bash
+# הוספת קובץ חדש לאינדקס (staging)
+git add hello.py
+# יצירת commit עם הודעה
+git commit -m "הוספת קובץ hello.py"
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+repo = Repo('my_repo')
+# הוספת קובץ לאינדקס
+repo.index.add(['hello.py'])
+# יצירת commit
+repo.index.commit("הוספת קובץ hello.py")
+```
+
+## מונחים קשורים
+
+* [Repository (מאגר קוד)](./repository.md)
+* [Branch (ענף)](./branch.md)
+* [Merge (מיזוג)](./merge.md)
+* [Pull Request (בקשת משיכה)](./pull-request.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על Commits](https://git-scm.com/docs/git-commit)
+* [הסבר על Commits ב-GitHub Docs](https://docs.github.com/en/get-started/quickstart/github-glossary#commit)
diff --git a/sites/he/glossary/conflict.md b/sites/he/glossary/conflict.md
new file mode 100644
index 00000000..2da46684
--- /dev/null
+++ b/sites/he/glossary/conflict.md
@@ -0,0 +1,53 @@
+# Conflict (קונפליקט)
+
+**הגדרה קצרה:** קונפליקט הוא מצב במערכת ניהול גרסאות כמו **Git**, שבו יש התנגשות בין שינויים שבוצעו באותם קבצים או שורות קוד בשני ענפים שונים, בעת ניסיון למזג (merge) או למשוך (rebase) שינויים.
+
+## הסבר מורחב
+
+`Conflict` (קונפליקט) מתרחש כאשר Git אינו מצליח לשלב אוטומטית שינויים שבוצעו במקביל על ידי מפתחים שונים, בדרך כלל באותם אזורים של קובץ. במצב זה, Git מסמן את הקבצים הבעייתיים, ויש לפתור את ההתנגשות ידנית: לבחור אילו שינויים לשמור, לשלב בין הגרסאות, או לכתוב קוד חדש. לאחר פתרון הקונפליקט, יש לסמן ל-Git שהבעיה נפתרה ולהמשיך בתהליך המיזוג או ה-rebase.
+
+היתרונות העיקריים של **Conflict** (כאשר פותרים אותו נכון):
+* **בקרה על שינויים:** מאפשר בחירה מודעת של הקוד שייכנס לגרסה הסופית.
+* **שיתוף פעולה בטוח:** מונע דריסה לא מכוונת של שינויים של אחרים.
+
+**דוגמאות לשימוש נפוץ:**
+* ניסיון למזג שני ענפים ששניהם שינו את אותה שורת קוד.
+* ביצוע rebase לענף שיש בו שינויים מתנגשים עם הענף הראשי.
+* פתרון קונפליקט על ידי עריכת הקובץ, מחיקת סימוני Git, ושמירת הגרסה הנכונה.
+
+## דוגמת קוד
+
+### יצירת קונפליקט ומצבו בקובץ
+נניח שיש לנו קובץ בשם `example.txt` ושני ענפים: `main` ו-`feature`.
+
+1. בשני הענפים מבוצעים שינויים באותה שורה בקובץ.
+2. בעת ניסיון למזג (`merge`) את `feature` ל-`main`, נוצר קונפליקט.
+
+כך ייראה הקובץ לאחר הקונפליקט:
+```text
+<<<<<<< HEAD
+תוכן מהענף הראשי (main)
+=======
+תוכן מהענף המשני (feature)
+>>>>>>> feature
+```
+
+### פתרון קונפליקט ב-Git
+1. עורכים את הקובץ, בוחרים את הגרסה הרצויה (או משלבים בין הגרסאות), ומוחקים את הסימונים (`<<<<<<<`, `=======`, `>>>>>>>`).
+2. מסמנים ל-Git שהקונפליקט נפתר:
+```bash
+git add example.txt
+git commit
+```
+
+## מונחים קשורים
+
+* [Merge (מיזוג)](./merge.md)
+* [Branch (ענף)](./branch.md)
+* [Commit (התחייבות)](./commit.md)
+* [Pull Request (בקשת משיכה)](./pull-request.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על קונפליקטים](https://git-scm.com/docs/git-merge#_how_conflicts_are_presented)
+* [הסבר על קונפליקטים ב-GitHub Docs](https://docs.github.com/en/get-started/quickstart/github-glossary#conflict) 
\ No newline at end of file
diff --git a/sites/he/glossary/diff.md b/sites/he/glossary/diff.md
new file mode 100644
index 00000000..66dce2c0
--- /dev/null
+++ b/sites/he/glossary/diff.md
@@ -0,0 +1,365 @@
+ # Diff (הצגת הבדלים)
+
+**הגדרה קצרה:** פקודה ב-Git המציגה את ההבדלים בין גרסאות שונות של קבצים, בין ענפים, או בין התחייבויות שונות, במטרה להבין מה השתנה.
+
+## הסבר מורחב
+
+`Diff` (הצגת הבדלים) הוא כלי חיוני ב-Git שמאפשר לך לראות את ההבדלים בין מצבים שונים במאגר. הפקודה מציגה:
+
+* **שורות שנוספו** (marked with +)
+* **שורות שנמחקו** (marked with -)
+* **שורות שלא השתנו** (context lines)
+* **מידע על הקובץ** (file path, mode changes)
+
+היתרונות העיקריים של **Diff** הם:
+* **בדיקת שינויים:** מאפשר לראות בדיוק מה השתנה.
+* **דיבוג:** עוזר למצוא באגים ולהבין מה השתבש.
+* **בקרת איכות:** מאפשר לבדוק שינויים לפני commit.
+* **תיעוד:** מספק תיעוד ויזואלי של השינויים.
+
+**דוגמאות לשימוש נפוץ:**
+* בדיקת שינויים לפני commit.
+* השוואה בין ענפים שונים.
+* בדיקת שינויים של התחייבות ספציפית.
+* השוואה בין גרסאות שונות של קובץ.
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# הצגת הבדלים בין working directory ל-staging area
+git diff
+
+# הצגת הבדלים בין staging area ל-HEAD
+git diff --staged
+git diff --cached
+
+# הצגת הבדלים בין שתי התחייבויות
+git diff commit1 commit2
+git diff HEAD~1 HEAD
+
+# הצגת הבדלים בין ענפים
+git diff main feature-branch
+
+# הצגת הבדלים של קובץ ספציפי
+git diff file.txt
+git diff -- file.txt
+
+# הצגת הבדלים עם פורמט מותאם אישית
+git diff --word-diff
+git diff --color-words
+
+# הצגת הבדלים עם מספר שורות context
+git diff -U5
+git diff --unified=10
+
+# הצגת הבדלים עם פורמט קצר
+git diff --stat
+
+# הצגת הבדלים עם פורמט מפורט
+git diff --numstat
+
+# הצגת הבדלים עם פורמט JSON
+git diff --porcelain
+
+# הצגת הבדלים עם פורמט patch
+git diff --patch
+
+# הצגת הבדלים עם פורמט side-by-side
+git diff --side-by-side
+
+# הצגת הבדלים עם פורמט word-by-word
+git diff --word-diff=color
+
+# הצגת הבדלים עם פורמט line-by-line
+git diff --word-diff=plain
+
+# הצגת הבדלים עם פורמט character-by-character
+git diff --word-diff=porcelain
+
+# הצגת הבדלים עם פורמט unified
+git diff --unified=3
+
+# הצגת הבדלים עם פורמט context
+git diff --context=3
+
+# הצגת הבדלים עם פורמט ed
+git diff --ed
+
+# הצגת הבדלים עם פורמט rcs
+git diff --rcs
+
+# הצגת הבדלים עם פורמט summary
+git diff --summary
+
+# הצגת הבדלים עם פורמט name-only
+git diff --name-only
+
+# הצגת הבדלים עם פורמט name-status
+git diff --name-status
+
+# הצגת הבדלים עם פורמט raw
+git diff --raw
+
+# הצגת הבדלים עם פורמט binary
+git diff --binary
+
+# הצגת הבדלים עם פורמט text
+git diff --text
+
+# הצגת הבדלים עם פורמט ignore-space-change
+git diff --ignore-space-change
+
+# הצגת הבדלים עם פורמט ignore-all-space
+git diff --ignore-all-space
+
+# הצגת הבדלים עם פורמט ignore-blank-lines
+git diff --ignore-blank-lines
+
+# הצגת הבדלים עם פורמט ignore-cr-at-eol
+git diff --ignore-cr-at-eol
+
+# הצגת הבדלים עם פורמט ignore-space-at-eol
+git diff --ignore-space-at-eol
+
+# הצגת הבדלים עם פורמט ignore-trailing-space
+git diff --ignore-trailing-space
+
+# הצגת הבדלים עם פורמט ignore-leading-space
+git diff --ignore-leading-space
+
+# הצגת הבדלים עם פורמט ignore-space-at-eol
+git diff --ignore-space-at-eol
+
+# הצגת הבדלים עם פורמט ignore-cr-at-eol
+git diff --ignore-cr-at-eol
+
+# הצגת הבדלים עם פורמט ignore-blank-lines
+git diff --ignore-blank-lines
+
+# הצגת הבדלים עם פורמט ignore-all-space
+git diff --ignore-all-space
+
+# הצגת הבדלים עם פורמט ignore-space-change
+git diff --ignore-space-change
+
+# הצגת הבדלים עם פורמט text
+git diff --text
+
+# הצגת הבדלים עם פורמט binary
+git diff --binary
+
+# הצגת הבדלים עם פורמט raw
+git diff --raw
+
+# הצגת הבדלים עם פורמט name-status
+git diff --name-status
+
+# הצגת הבדלים עם פורמט name-only
+git diff --name-only
+
+# הצגת הבדלים עם פורמט summary
+git diff --summary
+
+# הצגת הבדלים עם פורמט rcs
+git diff --rcs
+
+# הצגת הבדלים עם פורמט ed
+git diff --ed
+
+# הצגת הבדלים עם פורמט context
+git diff --context=3
+
+# הצגת הבדלים עם פורמט unified
+git diff --unified=3
+
+# הצגת הבדלים עם פורמט character-by-character
+git diff --word-diff=porcelain
+
+# הצגת הבדלים עם פורמט line-by-line
+git diff --word-diff=plain
+
+# הצגת הבדלים עם פורמט word-by-word
+git diff --word-diff=color
+
+# הצגת הבדלים עם פורמט side-by-side
+git diff --side-by-side
+
+# הצגת הבדלים עם פורמט patch
+git diff --patch
+
+# הצגת הבדלים עם פורמט porcelain
+git diff --porcelain
+
+# הצגת הבדלים עם פורמט מפורט
+git diff --numstat
+
+# הצגת הבדלים עם פורמט קצר
+git diff --stat
+
+# הצגת הבדלים עם פורמט word-by-word
+git diff --word-diff
+
+# הצגת הבדלים עם פורמט מותאם אישית
+git diff --color-words
+
+# הצגת הבדלים של קובץ ספציפי
+git diff -- file.txt
+
+# הצגת הבדלים של קובץ ספציפי
+git diff file.txt
+
+# הצגת הבדלים בין ענפים
+git diff feature-branch
+
+# הצגת הבדלים בין ענפים
+git diff main feature-branch
+
+# הצגת הבדלים בין שתי התחייבויות
+git diff HEAD~1 HEAD
+
+# הצגת הבדלים בין שתי התחייבויות
+git diff commit1 commit2
+
+# הצגת הבדלים בין staging area ל-HEAD
+git diff --cached
+
+# הצגת הבדלים בין staging area ל-HEAD
+git diff --staged
+
+# הצגת הבדלים בין working directory ל-staging area
+git diff
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+import os
+
+repo = Repo('my_repo')
+
+# הצגת הבדלים בסיסיים
+def show_basic_diff(repo):
+    """הצגת הבדלים בסיסיים"""
+    try:
+        diff = repo.git.diff()
+        if diff:
+            print("הבדלים בין working directory ל-staging area:")
+            print(diff)
+        else:
+            print("אין הבדלים")
+    except Exception as e:
+        print(f"שגיאה בהצגת הבדלים: {e}")
+
+# הצגת הבדלים של קובץ ספציפי
+def show_file_diff(repo, file_path):
+    """הצגת הבדלים של קובץ ספציפי"""
+    try:
+        diff = repo.git.diff('--', file_path)
+        if diff:
+            print(f"הבדלים בקובץ {file_path}:")
+            print(diff)
+        else:
+            print(f"אין הבדלים בקובץ {file_path}")
+    except Exception as e:
+        print(f"שגיאה בהצגת הבדלים של {file_path}: {e}")
+
+# הצגת הבדלים בין התחייבויות
+def show_commit_diff(repo, commit1, commit2):
+    """הצגת הבדלים בין שתי התחייבויות"""
+    try:
+        diff = repo.git.diff(commit1, commit2)
+        if diff:
+            print(f"הבדלים בין {commit1[:8]} ל-{commit2[:8]}:")
+            print(diff)
+        else:
+            print("אין הבדלים בין ההתחייבויות")
+    except Exception as e:
+        print(f"שגיאה בהצגת הבדלים בין התחייבויות: {e}")
+
+# הצגת הבדלים בין ענפים
+def show_branch_diff(repo, branch1, branch2):
+    """הצגת הבדלים בין שני ענפים"""
+    try:
+        diff = repo.git.diff(branch1, branch2)
+        if diff:
+            print(f"הבדלים בין ענף {branch1} לענף {branch2}:")
+            print(diff)
+        else:
+            print("אין הבדלים בין הענפים")
+    except Exception as e:
+        print(f"שגיאה בהצגת הבדלים בין ענפים: {e}")
+
+# הצגת הבדלים עם סטטיסטיקות
+def show_diff_stats(repo):
+    """הצגת הבדלים עם סטטיסטיקות"""
+    try:
+        stats = repo.git.diff('--stat')
+        if stats:
+            print("סטטיסטיקות הבדלים:")
+            print(stats)
+        else:
+            print("אין הבדלים")
+    except Exception as e:
+        print(f"שגיאה בהצגת סטטיסטיקות: {e}")
+
+# הצגת הבדלים עם פורמט מותאם אישית
+def show_custom_diff(repo, format_type='word-diff'):
+    """הצגת הבדלים עם פורמט מותאם אישית"""
+    try:
+        if format_type == 'word-diff':
+            diff = repo.git.diff('--word-diff')
+        elif format_type == 'stat':
+            diff = repo.git.diff('--stat')
+        elif format_type == 'name-only':
+            diff = repo.git.diff('--name-only')
+        else:
+            diff = repo.git.diff()
+        
+        if diff:
+            print(f"הבדלים בפורמט {format_type}:")
+            print(diff)
+        else:
+            print("אין הבדלים")
+    except Exception as e:
+        print(f"שגיאה בהצגת הבדלים בפורמט {format_type}: {e}")
+
+# דוגמה לשימוש
+if __name__ == "__main__":
+    # הצגת הבדלים בסיסיים
+    show_basic_diff(repo)
+    
+    # הצגת הבדלים של קובץ ספציפי
+    show_file_diff(repo, "README.md")
+    
+    # הצגת הבדלים בין התחייבויות
+    commits = list(repo.iter_commits('HEAD', max_count=2))
+    if len(commits) >= 2:
+        show_commit_diff(repo, commits[1].hexsha, commits[0].hexsha)
+    
+    # הצגת הבדלים בין ענפים
+    show_branch_diff(repo, "main", "develop")
+    
+    # הצגת סטטיסטיקות
+    show_diff_stats(repo)
+    
+    # הצגת הבדלים בפורמטים שונים
+    show_custom_diff(repo, 'word-diff')
+    show_custom_diff(repo, 'stat')
+    show_custom_diff(repo, 'name-only')
+```
+
+## מונחים קשורים
+
+* [Status (מצב)](./status.md)
+* [Commit (התחייבות)](./commit.md)
+* [Branch (ענף)](./branch.md)
+* [Staging Area (אזור ההכנה)](./staging.md)
+* [Working Directory (אזור העבודה)](./working-directory.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על git diff](https://git-scm.com/docs/git-diff)
+* [Git Diff Tutorial](https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository)
+* [GitPython Documentation](https://gitpython.readthedocs.io/en/stable/reference.html#git.cmd.Git.diff)
+* [Understanding Git Diff](https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository#_viewing_changes)
\ No newline at end of file
diff --git a/sites/he/glossary/fetch.md b/sites/he/glossary/fetch.md
new file mode 100644
index 00000000..3556151f
--- /dev/null
+++ b/sites/he/glossary/fetch.md
@@ -0,0 +1,49 @@
+# Fetch (משיכה ללא מיזוג)
+
+**הגדרה קצרה:** Fetch היא פעולה במערכת ניהול גרסאות כמו **Git**, שבה מביאים (מורידים) עדכונים ושינויים מהמאגר המרוחק (remote repository) אל המאגר המקומי (local repository), אך בניגוד ל-Pull, השינויים אינם מתמזגים אוטומטית לענף הפעיל.
+
+## הסבר מורחב
+
+`Fetch` (משיכה ללא מיזוג) מאפשרת לעדכן את המידע המקומי לגבי כל השינויים שבוצעו במאגר המרוחק, מבלי לשנות את הקבצים או הענף הפעיל במאגר המקומי. הפקודה `git fetch` מורידה את כל ההתחייבויות (commits), הענפים והתגיות החדשים מהמאגר המרוחק, אך לא מבצעת מיזוג (merge) אוטומטי. כך ניתן לבדוק את השינויים, להשוות, ולשלוט מתי וכיצד למזג אותם לענף המקומי.
+
+היתרונות העיקריים של **Fetch** הם:
+* **שליטה מלאה:** מאפשר לבדוק שינויים לפני שממזגים אותם לקוד המקומי.
+* **עדכון מידע:** שומר את המידע המקומי עדכני לגבי מצב המאגר המרוחק.
+* **מניעת קונפליקטים מיותרים:** מאפשר למנוע מיזוג אוטומטי לא רצוי.
+
+**דוגמאות לשימוש נפוץ:**
+* עדכון מידע מהמאגר המרוחק: `git fetch origin`
+* בדיקת שינויים שבוצעו בענפים מרוחקים לפני מיזוגם.
+* השוואת ההיסטוריה בין הענף המקומי למרוחק.
+
+## דוגמת קוד
+
+### פקודת Git בטרמינל
+```bash
+# משיכת עדכונים מהמאגר המרוחק ללא מיזוג
+git fetch origin
+
+# משיכת עדכונים מכל המאגרים המרוחקים
+git fetch --all
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+repo = Repo('my_repo')
+origin = repo.remote(name='origin')
+# משיכת כל השינויים מהמאגר המרוחק (ללא מיזוג)
+origin.fetch()
+```
+
+## מונחים קשורים
+
+* [Pull (משיכה)](./pull.md)
+* [Push (דחיפה)](./push.md)
+* [Merge (מיזוג)](./merge.md)
+* [Remote (מאגר מרוחק)](./remote.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על Fetch](https://git-scm.com/docs/git-fetch)
+* [הסבר על Fetch ב-GitHub Docs](https://docs.github.com/en/get-started/quickstart/github-glossary#fetch) 
\ No newline at end of file
diff --git a/sites/he/glossary/fork.md b/sites/he/glossary/fork.md
new file mode 100644
index 00000000..f3b839bb
--- /dev/null
+++ b/sites/he/glossary/fork.md
@@ -0,0 +1,43 @@
+# Fork (מזלג)
+
+**הגדרה קצרה:** פעולה במערכת ניהול הגרסאות **Git** ובפלטפורמות כמו **GitHub**, שבה נוצר עותק אישי של מאגר קוד (**repository**) בחשבון המשתמש. עותק זה מאפשר לבצע שינויים באופן עצמאי מבלי להשפיע על המאגר המקורי.
+
+## הסבר מורחב
+
+`Fork` (מזלג) הוא מונח מרכזי בעולם **הקוד הפתוח**. כאשר מפתח רוצה לתרום לפרויקט קיים, הוא אינו משנה ישירות את הקוד המקורי. במקום זאת, הוא יוצר "מזלג" של המאגר המקורי. פעולה זו יוצרת עותק מלא של המאגר (כולל כל ההיסטוריה והענפים) בחשבון ה-**GitHub** של המפתח.
+
+היתרונות העיקריים של **Fork** הם:
+* **עבודה עצמאית:** ניתן לעבוד על השינויים, לבצע התחייבויות (`commits`) ולדחוף (`push`) אותם ל-`Fork` האישי, מבלי צורך בהרשאות כתיבה למאגר המקורי.
+* **ניסוי וטעייה:** מאפשר למפתחים להתנסות, לבדוק רעיונות ולשנות קוד בחופשיות.
+* **הגשת תרומות:** לאחר שהשינויים מוכנים, ניתן להציע אותם למאגר המקורי באמצעות `בקשת משיכה` (**Pull Request**).
+
+**דוגמאות לשימוש נפוץ:**
+* כאשר רוצים לתרום פיצ'ר חדש לפרויקט **קוד פתוח**.
+* כאשר רוצים לתקן **באג** בפרויקט שאין לך הרשאות כתיבה אליו.
+* כאשר רוצים ליצור גרסה משלך לפרויקט קיים (לדוגמה, פרויקט שהבעלים המקורי הפסיקו לתחזק).
+
+## דוגמת קוד
+
+### יצירת Fork ב-GitHub (דרך הממשק הגרפי)
+1. נכנסים לעמוד המאגר שברצונך למזלג (fork) ב-GitHub.
+2. לוחצים על כפתור "Fork" (בפינה הימנית העליונה).
+3. בוחרים את החשבון/ארגון אליו ייווצר ה-fork.
+
+### שכפול (Clone) של ה-Fork למחשב המקומי
+```bash
+# לאחר יצירת ה-fork, משכפלים אותו למחשב המקומי
+# יש להחליף USERNAME בשם המשתמש שלך
+# ויש להחליף REPO בשם המאגר
+
+git clone https://github.com/USERNAME/REPO.git
+```
+
+## מונחים קשורים
+
+* [Repository (מאגר קוד)](./repository.md)
+* [Clone (שכפול)](./clone.md)
+* [Pull Request (בקשת משיכה)](./pull-request.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד GitHub על Forks](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/about-forks)
\ No newline at end of file
diff --git a/sites/he/glossary/git.md b/sites/he/glossary/git.md
new file mode 100644
index 00000000..ce771e3e
--- /dev/null
+++ b/sites/he/glossary/git.md
@@ -0,0 +1,53 @@
+ # Git (גיט)
+
+**הגדרה קצרה:** Git היא מערכת ניהול גרסאות מבוזרת (Distributed Version Control System) בקוד פתוח, המאפשרת מעקב אחר שינויים בקוד, שיתוף פעולה בין מפתחים, וניהול היסטוריית פיתוח של פרויקטים.
+
+## הסבר מורחב
+
+Git פותחה על ידי לינוס טורבאלדס בשנת 2005, במטרה לנהל את קוד הליבה של לינוקס. מאז הפכה לסטנדרט בתעשיית התוכנה. Git מאפשרת לכל מפתח לעבוד עם עותק מקומי מלא של כל ההיסטוריה של הפרויקט, לבצע שינויים, ליצור ענפים (branches), למזג (merge) פיתוחים, ולשחזר גרסאות קודמות בקלות. בזכות הארכיטקטורה המבוזרת, אין תלות בשרת מרכזי – כל מאגר (repository) הוא עצמאי לחלוטין.
+
+היתרונות העיקריים של **Git** הם:
+* **מעקב אחר שינויים:** כל שינוי מתועד, כולל מי, מתי ומה שונה.
+* **עבודה מבוזרת:** כל מפתח עובד עם עותק מלא של המאגר.
+* **שיתוף פעולה:** קל לשלב פיתוחים ממפתחים שונים.
+* **ביצועים גבוהים:** פעולות כמו commit, branch ו-merge מהירות מאוד.
+* **קוד פתוח:** חינמית, זמינה לכל מערכת הפעלה, ומפותחת בקוד פתוח.
+
+**דוגמאות לשימוש נפוץ:**
+* יצירת מאגר חדש: `git init`
+* שכפול מאגר קיים: `git clone https://github.com/user/repo.git`
+* שמירת שינויים: `git commit -m "הודעה"`
+* יצירת ענף חדש: `git branch feature/login`
+
+## דוגמת קוד
+
+### פקודות Git בסיסיות בטרמינל
+```bash
+# יצירת מאגר חדש בתיקיה נוכחית
+git init
+
+# שכפול מאגר קיים
+git clone https://github.com/USERNAME/REPO.git
+
+# בדיקת סטטוס הקבצים
+git status
+
+# הוספת קובץ לאינדקס
+git add file.txt
+
+# יצירת commit
+git commit -m "הוספת קובץ חדש"
+```
+
+## מונחים קשורים
+
+* [Repository (מאגר קוד)](./repository.md)
+* [Branch (ענף)](./branch.md)
+* [Commit (התחייבות)](./commit.md)
+* [Merge (מיזוג)](./merge.md)
+* [Tag (תגית)](./tag.md)
+
+## מקורות מידע נוספים
+
+* [האתר הרשמי של Git](https://git-scm.com/)
+* [מדריך Git בעברית (גיטהאב)](https://he.wikipedia.org/wiki/Git)
diff --git a/sites/he/glossary/github.md b/sites/he/glossary/github.md
new file mode 100644
index 00000000..a5f253c1
--- /dev/null
+++ b/sites/he/glossary/github.md
@@ -0,0 +1,49 @@
+# GitHub (גיטהאב)
+
+**הגדרה קצרה:** GitHub היא פלטפורמה מבוססת ענן לניהול מאגרי קוד (repositories) באמצעות Git, המאפשרת שיתוף פעולה, ניהול גרסאות, ניהול משימות, ביקורת קוד, הפצת קוד פתוח ועוד.
+
+## הסבר מורחב
+
+GitHub היא אחת הפלטפורמות הפופולריות ביותר בעולם לפיתוח תוכנה בשיתוף פעולה. היא מספקת ממשק גרפי נוח לניהול מאגרי Git, כלים לניהול Pull Requests, Issues, Wiki, דפי תיעוד, CI/CD (באמצעות GitHub Actions), ניהול הרשאות, הפצת גרסאות (Releases) ועוד. GitHub משמשת הן לפרויקטים פרטיים והן לפרויקטים בקוד פתוח, ומאפשרת למפתחים מכל העולם לתרום, לדון, ולשפר קוד יחד.
+
+היתרונות העיקריים של **GitHub** הם:
+* **שיתוף פעולה גלובלי:** מאפשר למפתחים מכל העולם לעבוד יחד על פרויקטים.
+* **ניהול גרסאות נוח:** ממשק גרפי ופקודות API לניהול מאגרי Git.
+* **כלי ניהול משימות:** Issues, Projects, Wiki, Discussions.
+* **אינטגרציה עם כלים נוספים:** CI/CD, בדיקות, הפצה, ועוד.
+* **קהילה ענקית:** מיליוני פרויקטים בקוד פתוח, מדריכים, דוגמאות ותיעוד.
+
+**דוגמאות לשימוש נפוץ:**
+* יצירת מאגר חדש ב-GitHub.
+* פתיחת Pull Request לשילוב שינויים.
+* פתיחת Issue לדיווח על באג או בקשת פיצ'ר.
+* יצירת Release והפצת גרסה.
+
+## דוגמת קוד
+
+### יצירת מאגר חדש ב-GitHub (דרך הממשק הגרפי)
+1. נכנסים ל-[github.com](https://github.com/) ומתחברים לחשבון.
+2. לוחצים על כפתור "+" ובוחרים "New repository".
+3. ממלאים שם, תיאור, ובוחרים אם המאגר יהיה ציבורי או פרטי.
+4. לוחצים על "Create repository".
+
+### עבודה עם מאגר GitHub מהטרמינל
+```bash
+# שכפול מאגר קיים מ-GitHub
+git clone https://github.com/USERNAME/REPO.git
+
+# דחיפת שינויים למאגר ב-GitHub
+git push origin main
+```
+
+## מונחים קשורים
+
+* [Git (גיט)](./git.md)
+* [Repository (מאגר קוד)](./repository.md)
+* [Pull Request (בקשת משיכה)](./pull-request.md)
+* [Issue (בעיה/בקשה)](./issue.md)
+
+## מקורות מידע נוספים
+
+* [האתר הרשמי של GitHub](https://github.com/)
+* [תיעוד GitHub](https://docs.github.com/) 
\ No newline at end of file
diff --git a/sites/he/glossary/head.md b/sites/he/glossary/head.md
new file mode 100644
index 00000000..7d8e1623
--- /dev/null
+++ b/sites/he/glossary/head.md
@@ -0,0 +1,68 @@
+ # Staging Area (אזור ההכנה)
+
+**הגדרה קצרה:** אזור ביניים ב-Git שבו נשמרים השינויים שהוכנו ל-commit, לפני שהם נשמרים בהיסטוריה של המאגר.
+
+## הסבר מורחב
+
+`Staging Area` (אזור ההכנה) הוא אזור זמני שבו אתה מכין שינויים לפני commit. זה מאפשר לך לבחור בדיוק איזה שינויים לכלול ב-commit הבא, גם אם יש לך שינויים רבים בקבצים שונים.
+
+**דוגמאות לשימוש נפוץ:**
+* הכנת קבצים ל-commit
+* בחירת שינויים ספציפיים
+* בדיקת מה ייכלל ב-commit
+* ניקוי staging area
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# הוספת קובץ ל-staging area
+git add file.txt
+
+# הוספת כל השינויים
+git add .
+
+# הוספת קבצים לפי pattern
+git add *.js
+
+# הסרת קובץ מ-staging area
+git reset HEAD file.txt
+
+# הצגת מה ב-staging area
+git diff --staged
+
+# ניקוי staging area
+git reset
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+
+repo = Repo('my_repo')
+
+# בדיקת staging area
+def check_staging_area(repo):
+    staged_files = repo.index.diff('HEAD')
+    print(f"קבצים ב-staging area: {len(staged_files)}")
+    
+    for diff in staged_files:
+        print(f"  {diff.a_path}")
+
+# הוספת קובץ ל-staging area
+def stage_file(repo, file_path):
+    repo.index.add([file_path])
+    print(f"נוסף {file_path} ל-staging area")
+
+check_staging_area(repo)
+```
+
+## מונחים קשורים
+
+* [Add (הוספה)](./add.md)
+* [Commit (התחייבות)](./commit.md)
+* [Reset (איפוס)](./reset.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על Staging Area](https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository)
\ No newline at end of file
diff --git a/sites/he/glossary/history.md b/sites/he/glossary/history.md
new file mode 100644
index 00000000..51ff6302
--- /dev/null
+++ b/sites/he/glossary/history.md
@@ -0,0 +1,74 @@
+ # History (היסטוריה)
+
+**הגדרה קצרה:** רשימה מסודרת של כל ההתחייבויות (commits) במאגר Git, המציגה את התפתחות הפרויקט לאורך זמן.
+
+## הסבר מורחב
+
+`History` (היסטוריה) היא הרשימה המלאה של כל ההתחייבויות במאגר, מסודרות בסדר כרונולוגי. כל התחייבות מכילה מידע על השינויים שנעשו, מי עשה אותם, ומתי.
+
+**דוגמאות לשימוש נפוץ:**
+* מעקב אחר התפתחות הפרויקט
+* מציאת מתי הוכנס באג
+* הבנת מי עבד על מה
+* חזרה לגרסה קודמת
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# הצגת היסטוריה בסיסית
+git log
+
+# הצגת היסטוריה בקיצור
+git log --oneline
+
+# הצגת היסטוריה עם גרף
+git log --graph --oneline
+
+# הצגת היסטוריה של קובץ
+git log -- file.txt
+
+# הצגת היסטוריה של מפתח
+git log --author="שם"
+
+# הצגת היסטוריה לפי תאריך
+git log --since="2023-01-01"
+
+# הצגת היסטוריה עם מספר מוגבל
+git log -n 10
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+
+repo = Repo('my_repo')
+
+# הצגת היסטוריה בסיסית
+def show_history(repo, max_count=10):
+    for commit in repo.iter_commits('HEAD', max_count=max_count):
+        print(f"{commit.hexsha[:8]} - {commit.message.strip()}")
+
+# הצגת היסטוריה של קובץ
+def show_file_history(repo, file_path):
+    for commit in repo.iter_commits('HEAD', paths=file_path):
+        print(f"{commit.hexsha[:8]} - {commit.message.strip()}")
+
+# חיפוש בהיסטוריה
+def search_history(repo, search_term):
+    for commit in repo.iter_commits('HEAD'):
+        if search_term in commit.message:
+            print(f"{commit.hexsha[:8]} - {commit.message.strip()}")
+
+show_history(repo, 5)
+```
+
+## מונחים קשורים
+
+* [Log (היסטוריה)](./log.md)
+* [Commit (התחייבות)](./commit.md)
+* [Branch (ענף)](./branch.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על git log](https://git-scm.com/docs/git-log)
\ No newline at end of file
diff --git a/sites/he/glossary/issue.md b/sites/he/glossary/issue.md
new file mode 100644
index 00000000..3b412c34
--- /dev/null
+++ b/sites/he/glossary/issue.md
@@ -0,0 +1,43 @@
+ # Issue (בעיה/בקשה)
+
+**הגדרה קצרה:** Issue הוא כלי לניהול משימות, תקלות, בקשות פיצ'ר או הערות בפרויקטים מבוססי Git, בעיקר בפלטפורמות כמו **GitHub** ו-**GitLab**.
+
+## הסבר מורחב
+
+Issue (בעיה/בקשה) הוא אמצעי מרכזי לתקשורת בין מפתחים, משתמשים ומתחזקים של פרויקט. כל Issue הוא דיון ממוקד בנושא מסוים: באג, בקשת פיצ'ר, שאלה, תיעוד חסר, או כל משימה אחרת. ניתן להוסיף תיאורים, תגיות (labels), להקצות אחראים (assignees), לקשר Pull Requests, ולעקוב אחרי סטטוס הטיפול. ניהול נכון של Issues מאפשר מעקב מסודר אחרי התקדמות הפרויקט, תיעוד בעיות, ותעדוף משימות.
+
+היתרונות העיקריים של **Issue** הם:
+* **מעקב אחר תקלות ובקשות:** כל בעיה או בקשה מתועדת וניתנת למעקב.
+* **שיתוף פעולה:** מאפשר למפתחים ולמשתמשים לדווח, לדון ולפתור בעיות יחד.
+* **תעדוף וניהול משימות:** אפשר להוסיף תגיות, לקבוע עדיפויות ולהקצות אחראים.
+
+**דוגמאות לשימוש נפוץ:**
+* פתיחת Issue לדיווח על באג.
+* פתיחת Issue לבקשת פיצ'ר חדש.
+* קישור Pull Request ל-Issue רלוונטי.
+
+## דוגמת קוד
+
+### פתיחת Issue ב-GitHub (דרך הממשק הגרפי)
+1. נכנסים לעמוד המאגר ב-GitHub.
+2. לוחצים על "Issues" > "New issue".
+3. ממלאים כותרת ותיאור, מוסיפים תגיות ואחראים במידת הצורך.
+4. לוחצים על "Submit new issue".
+
+### פתיחת Issue מהטרמינל (באמצעות GitHub CLI)
+```bash
+# פתיחת Issue חדש
+gh issue create --title "באג: לא ניתן להיכנס" --body "בעת ניסיון כניסה מתקבלת שגיאה."
+```
+
+## מונחים קשורים
+
+* [Pull Request (בקשת משיכה)](./pull-request.md)
+* [Repository (מאגר קוד)](./repository.md)
+* [GitHub (גיטהאב)](./github.md)
+* [Project (פרויקט)](./project.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד GitHub על Issues](https://docs.github.com/en/issues/tracking-your-work-with-issues/about-issues)
+* [תיעוד GitLab על Issues](https://docs.gitlab.com/ee/user/project/issues/)
diff --git a/sites/he/glossary/log.md b/sites/he/glossary/log.md
new file mode 100644
index 00000000..88ab8185
--- /dev/null
+++ b/sites/he/glossary/log.md
@@ -0,0 +1,204 @@
+ # Log (הצגת היסטוריית התחייבויות)
+
+**הגדרה קצרה:** פקודה ב-Git המציגה את היסטוריית ההתחייבויות (commits) במאגר, כולל פרטים כמו זיהוי ההתחייבות, המחבר, התאריך וההודעה.
+
+## הסבר מורחב
+
+`Log` (הצגת היסטוריית התחייבויות) הוא כלי חיוני ב-Git שמאפשר לך לחקור את ההיסטוריה של המאגר. הפקודה מציגה מידע מפורט על כל ההתחייבויות, כולל:
+
+* **זיהוי ההתחייבות** (commit hash)
+* **מחבר ההתחייבות** (author)
+* **תאריך ההתחייבות**
+* **הודעת ההתחייבות** (commit message)
+* **היסטוריית השינויים** (מה השתנה)
+
+היתרונות העיקריים של **Log** הם:
+* **חקירה:** מאפשר להבין איך המאגר התפתח לאורך זמן.
+* **דיבוג:** עוזר למצוא מתי ואיפה הוכנס באג.
+* **תיעוד:** מספק תיעוד של השינויים שנעשו.
+* **שיתוף פעולה:** מאפשר להבין מה אחרים עשו במאגר.
+
+**דוגמאות לשימוש נפוץ:**
+* בדיקת היסטוריית שינויים בקובץ ספציפי.
+* מציאת התחייבות שבה הוכנס באג.
+* הבנת התפתחות פיצ'ר מסוים.
+* בדיקת פעילות של מפתח ספציפי.
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# הצגת היסטוריה בסיסית
+git log
+
+# הצגת היסטוריה בקיצור (על שורה אחת)
+git log --oneline
+
+# הצגת היסטוריה עם גרף
+git log --graph --oneline --all
+
+# הצגת היסטוריה עם פרטים מפורטים
+git log --stat
+
+# הצגת היסטוריה עם diff
+git log -p
+
+# הצגת היסטוריה של קובץ ספציפי
+git log -- file.txt
+git log --follow -- file.txt
+
+# הצגת היסטוריה של מפתח ספציפי
+git log --author="שם המפתח"
+
+# הצגת היסטוריה לפי תאריך
+git log --since="2023-01-01" --until="2023-12-31"
+
+# הצגת היסטוריה עם מספר התחייבויות מוגבל
+git log -n 10
+
+# הצגת היסטוריה עם פורמט מותאם אישית
+git log --pretty=format:"%h - %an, %ar : %s"
+
+# הצגת היסטוריה עם תגיות
+git log --decorate
+
+# הצגת היסטוריה עם שינויים
+git log --name-status
+
+# הצגת היסטוריה עם מספר השורות שהשתנו
+git log --numstat
+
+# הצגת היסטוריה עם חיפוש בהודעות
+git log --grep="באג"
+
+# הצגת היסטוריה עם חיפוש בתוכן
+git log -S "פונקציה"
+
+# הצגת היסטוריה עם פילטור לפי סוג שינוי
+git log --merges
+git log --no-merges
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+from datetime import datetime, timedelta
+
+repo = Repo('my_repo')
+
+# הצגת היסטוריה בסיסית
+def show_basic_log(repo, max_count=10):
+    """הצגת היסטוריה בסיסית"""
+    print("היסטוריית התחייבויות:")
+    for commit in repo.iter_commits('HEAD', max_count=max_count):
+        print(f"  {commit.hexsha[:8]} - {commit.author.name}: {commit.message.strip()}")
+
+# הצגת היסטוריה מפורטת
+def show_detailed_log(repo, max_count=5):
+    """הצגת היסטוריה מפורטת"""
+    print("היסטוריה מפורטת:")
+    for commit in repo.iter_commits('HEAD', max_count=max_count):
+        print(f"\nהתחייבות: {commit.hexsha}")
+        print(f"מחבר: {commit.author.name} <{commit.author.email}>")
+        print(f"תאריך: {commit.authored_datetime}")
+        print(f"הודעה: {commit.message.strip()}")
+        print(f"הורים: {[p.hexsha[:8] for p in commit.parents]}")
+
+# הצגת היסטוריה של קובץ ספציפי
+def show_file_log(repo, file_path, max_count=10):
+    """הצגת היסטוריה של קובץ ספציפי"""
+    try:
+        print(f"היסטוריה של {file_path}:")
+        for commit in repo.iter_commits('HEAD', paths=file_path, max_count=max_count):
+            print(f"  {commit.hexsha[:8]} - {commit.message.strip()}")
+    except Exception as e:
+        print(f"שגיאה בהצגת היסטוריה של {file_path}: {e}")
+
+# הצגת היסטוריה של מפתח ספציפי
+def show_author_log(repo, author_name, max_count=10):
+    """הצגת היסטוריה של מפתח ספציפי"""
+    print(f"התחייבויות של {author_name}:")
+    for commit in repo.iter_commits('HEAD', author=author_name, max_count=max_count):
+        print(f"  {commit.hexsha[:8]} - {commit.message.strip()}")
+
+# הצגת היסטוריה לפי תאריך
+def show_date_range_log(repo, since_date, until_date=None):
+    """הצגת היסטוריה בטווח תאריכים"""
+    if until_date is None:
+        until_date = datetime.now()
+    
+    print(f"התחייבויות מ-{since_date} עד {until_date}:")
+    for commit in repo.iter_commits('HEAD', since=since_date, until=until_date):
+        print(f"  {commit.hexsha[:8]} - {commit.authored_datetime.date()} - {commit.message.strip()}")
+
+# חיפוש התחייבויות לפי תוכן
+def search_commits_by_content(repo, search_term, max_count=10):
+    """חיפוש התחייבויות לפי תוכן"""
+    print(f"התחייבויות המכילות '{search_term}':")
+    for commit in repo.iter_commits('HEAD', max_count=max_count):
+        if search_term.lower() in commit.message.lower():
+            print(f"  {commit.hexsha[:8]} - {commit.message.strip()}")
+
+# הצגת סטטיסטיקות
+def show_commit_stats(repo, max_count=50):
+    """הצגת סטטיסטיקות התחייבויות"""
+    commits = list(repo.iter_commits('HEAD', max_count=max_count))
+    
+    # ספירת התחייבויות לפי מחבר
+    authors = {}
+    for commit in commits:
+        author = commit.author.name
+        authors[author] = authors.get(author, 0) + 1
+    
+    print("סטטיסטיקות התחייבויות:")
+    print(f"סה"כ התחייבויות: {len(commits)}")
+    print("\nהתחייבויות לפי מחבר:")
+    for author, count in sorted(authors.items(), key=lambda x: x[1], reverse=True):
+        print(f"  {author}: {count}")
+
+# הצגת היסטוריה עם גרף
+def show_graph_log(repo, max_count=20):
+    """הצגת היסטוריה עם גרף"""
+    print("היסטוריה עם גרף:")
+    for commit in repo.iter_commits('HEAD', max_count=max_count):
+        # יצירת גרף פשוט
+        level = len(list(commit.parents))
+        indent = "  " * level
+        print(f"{indent}* {commit.hexsha[:8]} - {commit.message.strip()}")
+
+# דוגמה לשימוש
+if __name__ == "__main__":
+    # הצגת היסטוריה בסיסית
+    show_basic_log(repo, 5)
+    
+    # הצגת היסטוריה מפורטת
+    show_detailed_log(repo, 3)
+    
+    # הצגת היסטוריה של קובץ ספציפי
+    show_file_log(repo, "README.md", 5)
+    
+    # הצגת היסטוריה לפי תאריך
+    week_ago = datetime.now() - timedelta(days=7)
+    show_date_range_log(repo, week_ago)
+    
+    # חיפוש התחייבויות
+    search_commits_by_content(repo, "באג", 10)
+    
+    # הצגת סטטיסטיקות
+    show_commit_stats(repo, 20)
+```
+
+## מונחים קשורים
+
+* [Commit (התחייבות)](./commit.md)
+* [Branch (ענף)](./branch.md)
+* [Diff (הבדלים)](./diff.md)
+* [Blame (האשמה)](./blame.md)
+* [History (היסטוריה)](./history.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על git log](https://git-scm.com/docs/git-log)
+* [Git Log Tutorial](https://git-scm.com/book/en/v2/Git-Basics-Viewing-the-Commit-History)
+* [GitPython Documentation](https://gitpython.readthedocs.io/en/stable/reference.html#git.repo.base.Repo.iter_commits)
+* [Advanced Git Log Formatting](https://git-scm.com/docs/git-log#_pretty_formats)
\ No newline at end of file
diff --git a/sites/he/glossary/merge.md b/sites/he/glossary/merge.md
new file mode 100644
index 00000000..33dbf272
--- /dev/null
+++ b/sites/he/glossary/merge.md
@@ -0,0 +1,49 @@
+# Merge (מיזוג)
+
+**הגדרה קצרה:** מיזוג הוא פעולה במערכת ניהול גרסאות כמו **Git**, שבה משלבים שינויים מענף אחד (branch) לענף אחר, לרוב מהענף המשני (feature/bugfix) לענף הראשי (main/master).
+
+## הסבר מורחב
+
+`Merge` (מיזוג) הוא תהליך מרכזי בעבודה בצוות ובפיתוח מקבילי. כאשר עובדים על פיצ'רים או תיקונים בענפים נפרדים, בסיום העבודה ממזגים את השינויים לענף הראשי כדי לשלב את כל הפיתוחים. Git מנסה לשלב אוטומטית את כל השינויים, אך אם יש שינויים סותרים באותם קבצים, נוצר "קונפליקט" (התנגשות) שיש לפתור ידנית.
+
+היתרונות העיקריים של **Merge** הם:
+* **שילוב פיתוחים:** מאפשר לאחד עבודה של מספר מפתחים/ות לענף מרכזי.
+* **שימור היסטוריה:** כל ההיסטוריה של הענפים נשמרת, כולל כל ה-commits.
+* **פיתוח במקביל:** מאפשר עבודה עצמאית על פיצ'רים ותיקונים מבלי להפריע לקוד הראשי.
+
+**דוגמאות לשימוש נפוץ:**
+* מיזוג ענף פיצ'ר לענף הראשי: `git merge feature/login`
+* פתרון קונפליקטים שנוצרו במהלך המיזוג.
+* מיזוג שינויים לאחר Pull Request.
+
+## דוגמת קוד
+
+### פקודת Git בטרמינל
+```bash
+# מעבר לענף הראשי (main)
+git checkout main
+# מיזוג ענף הפיצ'ר לענף הראשי
+git merge feature/login
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+repo = Repo('my_repo')
+# מעבר לענף הראשי
+repo.git.checkout('main')
+# מיזוג ענף הפיצ'ר
+repo.git.merge('feature/login')
+```
+
+## מונחים קשורים
+
+* [Branch (ענף)](./branch.md)
+* [Commit (התחייבות)](./commit.md)
+* [Pull Request (בקשת משיכה)](./pull-request.md)
+* [Conflict (קונפליקט)](./conflict.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על Merge](https://git-scm.com/docs/git-merge)
+* [הסבר על Merge ב-GitHub Docs](https://docs.github.com/en/get-started/quickstart/github-glossary#merge)
\ No newline at end of file
diff --git a/sites/he/glossary/project.md b/sites/he/glossary/project.md
new file mode 100644
index 00000000..1456030a
--- /dev/null
+++ b/sites/he/glossary/project.md
@@ -0,0 +1,45 @@
+# Project (פרויקט)
+
+**הגדרה קצרה:** Project הוא כלי לניהול משימות, תכנון, תעדוף ומעקב אחר התקדמות בפרויקטים של קוד פתוח או קוד סגור, בעיקר בפלטפורמות כמו **GitHub** ו-**GitLab**.
+
+## הסבר מורחב
+
+Project (פרויקט) בפלטפורמות ניהול קוד הוא לוח עבודה (Board) המאפשר לארגן Issues, Pull Requests ומשימות אחרות בעמודות (Columns) לפי סטטוס, עדיפות, או שלב בתהליך העבודה. ניתן ליצור לוחות Kanban, Roadmaps, או כל מבנה אחר שמתאים לצוות. כל Project מאפשר תצוגה ויזואלית של התקדמות, תעדוף משימות, הקצאת אחראים, ותכנון גרסאות עתידיות. הכלי מסייע בשקיפות, תיאום ושיתוף פעולה בין חברי הצוות.
+
+היתרונות העיקריים של **Project** הם:
+* **תכנון וארגון:** מאפשר תכנון מסודר של משימות, פיצ'רים ובאגים.
+* **מעקב ויזואלי:** תצוגה גרפית של סטטוס המשימות (למשל: To do, In progress, Done).
+* **שקיפות ושיתוף פעולה:** כל חברי הצוות רואים את התקדמות הפרויקט בזמן אמת.
+
+**דוגמאות לשימוש נפוץ:**
+* יצירת לוח Kanban לניהול משימות בפרויקט.
+* תעדוף Issues ו-Pull Requests לפי דחיפות.
+* תכנון Roadmap לגרסאות עתידיות.
+
+## דוגמת קוד
+
+### יצירת Project ב-GitHub (דרך הממשק הגרפי)
+1. נכנסים לעמוד המאגר או הארגון ב-GitHub.
+2. לוחצים על "Projects" > "New project".
+3. בוחרים תבנית (Kanban, Table, וכו'), נותנים שם ותיאור.
+4. מוסיפים Issues, Pull Requests או כרטיסים ידניים.
+
+### עבודה עם Projects מהטרמינל (באמצעות GitHub CLI)
+```bash
+# יצירת Project חדש (דורש הרשאות מתאימות)
+gh project create --title "Roadmap 2024" --format board
+
+# הצגת כל הפרויקטים במאגר
+gh project list
+```
+
+## מונחים קשורים
+
+* [Issue (בעיה/בקשה)](./issue.md)
+* [Pull Request (בקשת משיכה)](./pull-request.md)
+* [GitHub (גיטהאב)](./github.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד GitHub על Projects](https://docs.github.com/en/issues/planning-and-tracking-with-projects/learning-about-projects/about-projects)
+* [תיעוד GitLab על Issue Boards](https://docs.gitlab.com/ee/user/project/issue_board.html) 
\ No newline at end of file
diff --git a/sites/he/glossary/pull-request.md b/sites/he/glossary/pull-request.md
new file mode 100644
index 00000000..9d006e4e
--- /dev/null
+++ b/sites/he/glossary/pull-request.md
@@ -0,0 +1,59 @@
+# Pull Request (בקשת משיכה)
+
+**הגדרה קצרה:** פעולה בפלטפורמות ניהול קוד כמו **GitHub** ו-**GitLab**, המאפשרת למפתח להציע שינויים שביצע במאגר קוד (לרוב ב-Fork או בענף נפרד) כדי שייבחנו ויתמזגו (merge) למאגר המקורי.
+
+## הסבר מורחב
+
+`Pull Request` (בקשת משיכה) הוא תהליך מרכזי בשיתוף פעולה בפרויקטי קוד פתוח ובפיתוח צוותי. כאשר מפתח מסיים לבצע שינויים בקוד (לרוב ב-Fork או בענף branch), הוא יוצר Pull Request כדי להציע את השינויים למאגר המקורי. בעלי המאגר או המתחזקים בודקים את השינויים, מבצעים הערות וביקורות, ובסיום – יכולים לאשר ולמזג (merge) את השינויים לקוד הראשי.
+
+היתרונות העיקריים של **Pull Request** הם:
+* **ביקורת קוד:** מאפשר למתחזקים ולחברי צוות לבדוק, להעיר ולהציע שיפורים לפני מיזוג השינויים.
+* **תיעוד:** כל Pull Request מתועד, כולל היסטוריית שינויים, דיונים והערות.
+* **שיתוף פעולה:** מאפשר עבודה משותפת, גם בין אנשים שאין להם הרשאות ישירות לכתוב למאגר המקורי.
+
+**דוגמאות לשימוש נפוץ:**
+* כאשר רוצים להציע תיקון באג או פיצ'ר חדש לפרויקט קוד פתוח.
+* כאשר עובדים בצוות ורוצים שמישהו אחר יעבור על הקוד לפני מיזוגו.
+* כאשר רוצים לנהל תהליך מסודר של בדיקות וביקורות קוד.
+
+## דוגמת קוד
+
+### יצירת Pull Request ב-GitHub דרך הממשק הגרפי
+1. דוחפים (push) את השינויים לענף חדש במאגר המרוחק (למשל: `feature/login`).
+2. נכנסים לעמוד המאגר ב-GitHub, ולוחצים על "Compare & pull request".
+3. ממלאים כותרת ותיאור, ולוחצים על "Create pull request".
+
+### יצירת Pull Request מהטרמינל (באמצעות GitHub CLI)
+```bash
+# יצירת Pull Request מהענף הנוכחי לענף הראשי (main)
+gh pr create --base main --head feature/login --title "הוספת מסך התחברות" --body "הוספת מסך התחברות עם ולידציה."
+```
+
+### פייתון (שימוש בספריית PyGithub)
+```python
+from github import Github
+
+# התחברות ל-GitHub (יש להכניס טוקן אישי)
+g = Github("your_github_token")
+repo = g.get_repo("user/repo")
+
+# יצירת Pull Request
+pr = repo.create_pull(
+    title="הוספת מסך התחברות",
+    body="הוספת מסך התחברות עם ולידציה.",
+    head="feature/login",
+    base="main"
+)
+print(f"Pull Request created: {pr.html_url}")
+```
+
+## מונחים קשורים
+
+* [Repository (מאגר קוד)](./repository.md)
+* [Fork (מזלג)](./fork.md)
+* [Clone (שכפול)](./clone.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד GitHub על Pull Requests](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests)
+* [תיעוד GitLab על Merge Requests](https://docs.gitlab.com/ee/user/project/merge_requests/)
diff --git a/sites/he/glossary/pull.md b/sites/he/glossary/pull.md
new file mode 100644
index 00000000..17e7d144
--- /dev/null
+++ b/sites/he/glossary/pull.md
@@ -0,0 +1,49 @@
+# Pull (משיכה)
+
+**הגדרה קצרה:** משיכה היא פעולה במערכת ניהול גרסאות כמו **Git**, שבה מביאים (מורידים) עדכונים ושינויים מהמאגר המרוחק (remote repository) אל המאגר המקומי (local repository), כולל קבצים חדשים, commits ועדכונים בענפים.
+
+## הסבר מורחב
+
+`Pull` (משיכה) היא אחת הפעולות המרכזיות בעבודה עם Git בצוותים. כאשר עובדים מספר מפתחים על אותו פרויקט, כל אחד דוחף (push) שינויים למאגר המרוחק. כדי לקבל את השינויים של אחרים, יש לבצע `git pull`, שמבצע למעשה שתי פעולות: `fetch` (משיכת העדכונים מהמאגר המרוחק) ו-`merge` (מיזוג העדכונים לענף המקומי). לעיתים, אם יש קונפליקטים בין השינויים המקומיים לאלו שבמאגר המרוחק, יש לפתור אותם ידנית.
+
+היתרונות העיקריים של **Pull** הם:
+* **עדכון שוטף:** מאפשר לקבל את כל השינויים האחרונים שבוצעו על ידי חברי הצוות.
+* **מניעת קונפליקטים:** עוזר לשלב שינויים מוקדם ולמנוע התנגשות מאוחרת.
+* **שילוב עבודה בצוות:** מאפשר אינטגרציה של פיתוחים ממספר מפתחים.
+
+**דוגמאות לשימוש נפוץ:**
+* משיכת עדכונים מהענף הראשי: `git pull origin main`
+* קבלת שינויים שבוצעו על ידי אחרים לפני דחיפת (push) שינויים משלך.
+* פתרון קונפליקטים שנוצרו במהלך המשיכה.
+
+## דוגמת קוד
+
+### פקודת Git בטרמינל
+```bash
+# משיכת עדכונים מהמאגר המרוחק לענף הראשי
+git pull origin main
+
+# משיכת עדכונים לכל הענפים
+git pull --all
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+repo = Repo('my_repo')
+origin = repo.remote(name='origin')
+# משיכת כל השינויים מהמאגר המרוחק
+origin.pull()
+```
+
+## מונחים קשורים
+
+* [Push (דחיפה)](./push.md)
+* [Fetch (משיכה ללא מיזוג)](./fetch.md)
+* [Merge (מיזוג)](./merge.md)
+* [Conflict (קונפליקט)](./conflict.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על Pull](https://git-scm.com/docs/git-pull)
+* [הסבר על Pull ב-GitHub Docs](https://docs.github.com/en/get-started/quickstart/github-glossary#pull) 
\ No newline at end of file
diff --git a/sites/he/glossary/push.md b/sites/he/glossary/push.md
new file mode 100644
index 00000000..10b76c44
--- /dev/null
+++ b/sites/he/glossary/push.md
@@ -0,0 +1,49 @@
+# Push (דחיפה)
+
+**הגדרה קצרה:** דחיפה היא פעולה במערכת ניהול גרסאות כמו **Git**, שבה שולחים (מדביקים) שינויים ו-commits שבוצעו במאגר המקומי (local repository) אל מאגר מרוחק (remote repository), לדוגמה ב-GitHub או ב-GitLab.
+
+## הסבר מורחב
+
+`Push` (דחיפה) הוא שלב מרכזי בעבודה עם Git בצוותים ובפרויקטים משותפים. לאחר שמבצעים שינויים ושומרים אותם כ-commits במאגר המקומי, יש לדחוף (push) אותם אל המאגר המרוחק כדי לשתף את השינויים עם שאר חברי הצוות או לשמור גיבוי בענן. הפקודה `git push` מעבירה את כל ההתחייבויות (commits) והעדכונים לענף (branch) המתאים במאגר המרוחק. לעיתים, אם נעשו שינויים במאגר המרוחק מאז הפעם האחרונה שעדכנת, תידרש קודם למשוך (pull) את השינויים לפני שתוכל לדחוף.
+
+היתרונות העיקריים של **Push** הם:
+* **שיתוף שינויים:** מאפשר לכל חברי הצוות לראות ולעבוד עם השינויים שביצעת.
+* **גיבוי בענן:** שומר את הקוד וההיסטוריה שלו בשרת מרוחק.
+* **שילוב עבודה בצוות:** מאפשר אינטגרציה של פיתוחים ממספר מפתחים.
+
+**דוגמאות לשימוש נפוץ:**
+* דחיפת שינויים לענף הראשי: `git push origin main`
+* דחיפת ענף חדש למאגר מרוחק: `git push origin feature/login`
+* ניסיון לדחוף שינויים ולקבל הודעה שיש למשוך (pull) עדכונים לפני כן.
+
+## דוגמת קוד
+
+### פקודת Git בטרמינל
+```bash
+# דחיפת שינויים לענף הראשי במאגר המרוחק
+git push origin main
+
+# דחיפת ענף חדש בשם feature/login
+git push origin feature/login
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+repo = Repo('my_repo')
+origin = repo.remote(name='origin')
+# דחיפת כל השינויים למאגר המרוחק
+origin.push()
+```
+
+## מונחים קשורים
+
+* [Pull (משיכה)](./pull.md)
+* [Fetch (משיכה ללא מיזוג)](./fetch.md)
+* [Commit (התחייבות)](./commit.md)
+* [Remote (מאגר מרוחק)](./remote.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על Push](https://git-scm.com/docs/git-push)
+* [הסבר על Push ב-GitHub Docs](https://docs.github.com/en/get-started/quickstart/github-glossary#push) 
\ No newline at end of file
diff --git a/sites/he/glossary/rebase.md b/sites/he/glossary/rebase.md
new file mode 100644
index 00000000..3c03298b
--- /dev/null
+++ b/sites/he/glossary/rebase.md
@@ -0,0 +1,134 @@
+ # Rebase (שינוי בסיס הענף)
+
+**הגדרה קצרה:** פעולה ב-Git המאפשרת לשנות את נקודת הבסיס (base) של ענף, על ידי העתקת התחייבויות מענף אחד לענף אחר, בדרך כלל כדי ליצור היסטוריה ליניארית ונקייה יותר.
+
+## הסבר מורחב
+
+`Rebase` (שינוי בסיס הענף) הוא כלי מתקדם ב-Git שמאפשר "להעביר" התחייבויות מענף אחד לענף אחר. במקום ליצור merge commit שמשלב שני ענפים, rebase יוצר היסטוריה ליניארית על ידי העתקת התחייבויות מהענף הנוכחי אל קצה הענף היעד.
+
+היתרונות העיקריים של **Rebase** הם:
+* **היסטוריה נקייה:** יוצר היסטוריה ליניארית ללא merge commits מיותרים.
+* **קריאות טובה יותר:** היסטוריה ברורה וקלה להבנה.
+* **שליטה טובה יותר:** מאפשר לעצב את ההיסטוריה לפי הצורך.
+* **מניעת קונפליקטים:** יכול להפחית קונפליקטים בהשוואה ל-merge.
+
+**דוגמאות לשימוש נפוץ:**
+* עדכון ענף feature עם השינויים האחרונים מ-main.
+* ניקוי היסטוריה לפני merge ל-main.
+* שינוי סדר התחייבויות או שילוב התחייבויות קטנות.
+* יצירת היסטוריה נקייה לפרויקט.
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# rebase בסיסי - העתקת התחייבויות מ-main לענף הנוכחי
+git rebase main
+
+# rebase אינטראקטיבי - מאפשר לערוך, לשלב או למחוק התחייבויות
+git rebase -i HEAD~3
+
+# rebase עם המשך אוטומטי במקרה של קונפליקטים
+git rebase --continue
+
+# ביטול rebase
+git rebase --abort
+
+# rebase עם skip של התחייבות ספציפית
+git rebase --skip
+
+# rebase עם עריכת הודעת התחייבות
+git rebase -i --reword HEAD~2
+
+# rebase עם שילוב התחייבויות
+git rebase -i --squash HEAD~3
+
+# rebase עם ענף מרוחק
+git rebase origin/main
+
+# rebase עם שמירת merge commits
+git rebase --preserve-merges main
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+import os
+
+repo = Repo('my_repo')
+
+# rebase בסיסי
+try:
+    # העתקת התחייבויות מ-main לענף הנוכחי
+    repo.git.rebase('main')
+    print("Rebase הושלם בהצלחה")
+except Exception as e:
+    print(f"שגיאה ב-rebase: {e}")
+    # ביטול rebase במקרה של שגיאה
+    repo.git.rebase('--abort')
+
+# rebase אינטראקטיבי (דורש אינטראקציה ידנית)
+def interactive_rebase(repo, commits_count):
+    """ביצוע rebase אינטראקטיבי על מספר התחייבויות"""
+    try:
+        # יצירת קובץ זמני עם הוראות rebase
+        rebase_file = f"rebase-{commits_count}.txt"
+        with open(rebase_file, 'w') as f:
+            f.write(f"pick HEAD~{commits_count} התחייבות ראשונה\n")
+            f.write(f"pick HEAD~{commits_count-1} התחייבות שנייה\n")
+            f.write(f"pick HEAD~{commits_count-2} התחייבות שלישית\n")
+        
+        # ביצוע rebase עם הקובץ
+        repo.git.rebase('-i', f'HEAD~{commits_count}', 
+                       _env={'GIT_EDITOR': f'cat {rebase_file}'})
+        
+        # ניקוי קובץ זמני
+        os.remove(rebase_file)
+        print("Interactive rebase הושלם")
+        
+    except Exception as e:
+        print(f"שגיאה ב-interactive rebase: {e}")
+        repo.git.rebase('--abort')
+
+# בדיקת מצב לפני ואחרי rebase
+def check_rebase_status(repo):
+    """בדיקת מצב המאגר לפני ואחרי rebase"""
+    print("מצב לפני rebase:")
+    print(repo.git.log('--oneline', '-5'))
+    
+    try:
+        # ביצוע rebase
+        repo.git.rebase('main')
+        print("\nמצב אחרי rebase:")
+        print(repo.git.log('--oneline', '-5'))
+    except Exception as e:
+        print(f"שגיאה: {e}")
+        repo.git.rebase('--abort')
+
+# דוגמה לשימוש
+if __name__ == "__main__":
+    # בדיקת ענף נוכחי
+    current_branch = repo.active_branch.name
+    print(f"ענף נוכחי: {current_branch}")
+    
+    # ביצוע rebase רק אם לא על main
+    if current_branch != 'main':
+        check_rebase_status(repo)
+    else:
+        print("לא ניתן לבצע rebase על ענף main")
+```
+
+## מונחים קשורים
+
+* [Branch (ענף)](./branch.md)
+* [Merge (מיזוג)](./merge.md)
+* [Commit (התחייבות)](./commit.md)
+* [Conflict (קונפליקט)](./conflict.md)
+* [Checkout (מעבר)](./checkout.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על git rebase](https://git-scm.com/docs/git-rebase)
+* [Git Rebase Tutorial](https://git-scm.com/book/en/v2/Git-Branching-Rebasing)
+* [GitPython Documentation](https://gitpython.readthedocs.io/en/stable/reference.html#git.cmd.Git.rebase)
+* [Interactive Rebase Guide](https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History)
\ No newline at end of file
diff --git a/sites/he/glossary/release.md b/sites/he/glossary/release.md
new file mode 100644
index 00000000..b13cc1af
--- /dev/null
+++ b/sites/he/glossary/release.md
@@ -0,0 +1,44 @@
+ # Release (גרסה)
+
+**הגדרה קצרה:** גרסה (Release) היא הפצה רשמית של מצב מסוים של קוד בפרויקט, לרוב מסומנת באמצעות תגית (Tag) במערכת ניהול גרסאות כמו **Git**, ומשמשת כנקודת ייחוס יציבה לשימוש, הפצה או פריסה.
+
+## הסבר מורחב
+
+`Release` (גרסה) הוא מונח מרכזי בניהול פרויקטים ותוכנה. כאשר צוות פיתוח רוצה להכריז על גרסה יציבה של הפרויקט (למשל v1.0.0), הוא יוצר תגית (Tag) מתאימה, ולעיתים מוסיף קבצי Release Notes עם תיעוד השינויים, פיצ'רים חדשים ותיקוני באגים. בפלטפורמות כמו GitHub ו-GitLab, ניתן ליצור Release הכולל קבצים בינאריים, קוד מקור, תיעוד ועוד, ולהפיץ אותו למשתמשים.
+
+היתרונות העיקריים של **Release** הם:
+* **נקודת ייחוס יציבה:** מאפשר למשתמשים ומפתחים לחזור בקלות לגרסה מסוימת.
+* **הפצה מסודרת:** מאפשר הפצה של קוד, קבצים בינאריים ותיעוד בצורה מסודרת.
+* **מעקב אחר שינויים:** כל Release מתועד, כולל תיעוד שינויים (Release Notes).
+
+**דוגמאות לשימוש נפוץ:**
+* יצירת תגית לגרסה חדשה: `git tag v2.0.0`
+* יצירת Release ב-GitHub עם תיעוד וקבצים מצורפים.
+* הורדת גרסה מסוימת של פרויקט מה-Release Page.
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# יצירת תגית לגרסה חדשה
+git tag v2.0.0
+# דחיפת התגית למאגר מרוחק
+git push origin v2.0.0
+```
+
+### יצירת Release ב-GitHub (דרך הממשק הגרפי)
+1. נכנסים לעמוד המאגר ב-GitHub.
+2. לוחצים על "Releases" > "Draft a new release".
+3. בוחרים תגית (קיימת או חדשה), ממלאים תיאור, ומצרפים קבצים במידת הצורך.
+4. לוחצים על "Publish release".
+
+## מונחים קשורים
+
+* [Tag (תגית)](./tag.md)
+* [Commit (התחייבות)](./commit.md)
+* [Pull Request (בקשת משיכה)](./pull-request.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד GitHub על Releases](https://docs.github.com/en/repositories/releasing-projects-on-github/about-releases)
+* [תיעוד Git על Tag](https://git-scm.com/docs/git-tag)
diff --git a/sites/he/glossary/remote.md b/sites/he/glossary/remote.md
new file mode 100644
index 00000000..56644750
--- /dev/null
+++ b/sites/he/glossary/remote.md
@@ -0,0 +1,56 @@
+# Remote (מאגר מרוחק)
+
+**הגדרה קצרה:** מאגר מרוחק הוא עותק של מאגר קוד (**repository**) שנמצא בשרת חיצוני (למשל GitHub, GitLab או שרת פרטי), ומאפשר שיתוף פעולה בין מפתחים על אותו פרויקט באמצעות רשת האינטרנט.
+
+## הסבר מורחב
+
+`Remote` (מאגר מרוחק) הוא רכיב מרכזי בעבודה עם Git בצוותים ובפרויקטים משותפים. כל מאגר מקומי (local repository) יכול להיות מקושר לאחד או יותר מאגרים מרוחקים. ברירת המחדל לרוב נקראת `origin`. באמצעות פקודות כמו `git push`, `git pull` ו-`git fetch` ניתן לשלוח ולקבל שינויים בין המאגר המקומי למרוחק. כך ניתן לעבוד בצוות, לשמור גיבוי בענן, ולשלב פיתוחים ממפתחים שונים.
+
+היתרונות העיקריים של **Remote** הם:
+* **שיתוף פעולה:** מאפשר למספר מפתחים לעבוד יחד על אותו פרויקט מכל מקום בעולם.
+* **גיבוי:** שומר עותק עדכני של הקוד וההיסטוריה שלו בשרת חיצוני.
+* **ניהול גרסאות מרכזי:** מאפשר שליטה על גרסאות ועדכונים בפרויקט.
+
+**דוגמאות לשימוש נפוץ:**
+* קישור מאגר מקומי למרוחק: `git remote add origin https://github.com/user/repo.git`
+* בדיקת רשימת המאגרים המרוחקים: `git remote -v`
+* עבודה עם מספר מאגרים מרוחקים (למשל origin ו-upstream).
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# הוספת מאגר מרוחק חדש בשם origin
+git remote add origin https://github.com/user/repo.git
+
+# הצגת כל המאגרים המרוחקים
+git remote -v
+
+# הסרת מאגר מרוחק
+git remote remove origin
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+repo = Repo('my_repo')
+
+# הצגת כל המאגרים המרוחקים
+for remote in repo.remotes:
+    print(remote.name, remote.url)
+
+# הוספת מאגר מרוחק חדש
+repo.create_remote('origin', 'https://github.com/user/repo.git')
+```
+
+## מונחים קשורים
+
+* [Push (דחיפה)](./push.md)
+* [Pull (משיכה)](./pull.md)
+* [Fetch (משיכה ללא מיזוג)](./fetch.md)
+* [Repository (מאגר קוד)](./repository.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על Remote](https://git-scm.com/docs/git-remote)
+* [הסבר על Remote ב-GitHub Docs](https://docs.github.com/en/get-started/quickstart/github-glossary#remote) 
\ No newline at end of file
diff --git a/sites/he/glossary/repository.md b/sites/he/glossary/repository.md
new file mode 100644
index 00000000..4d6d3ef1
--- /dev/null
+++ b/sites/he/glossary/repository.md
@@ -0,0 +1,42 @@
+# Repository (מאגר קוד)
+
+**הגדרה קצרה:** `Repository` (מאגר קוד) הוא תיקייה מיוחדת בפרויקט תוכנה, הנמצאת תחת מעקב של מערכת ניהול גרסאות כמו **Git**. הוא מכיל את כל הקבצים של הפרויקט, יחד עם היסטוריית השינויים המלאה שלהם.
+
+## הסבר מורחב
+
+מאגר קוד, או **Repository**, הוא הלב של כל פרויקט שמנוהל באמצעות מערכת בקרת גרסאות. זהו למעשה אוסף של קבצים ותיקיות, בתוספת היסטוריה מפורטת של כל שינוי שבוצע בהם לאורך זמן. הריפוזיטורי מאפשר למפתחים:
+
+* **מעקב אחר שינויים:** לדעת בדיוק מי, מתי ומה שונה בכל קובץ.
+* **שיתוף פעולה:** מספר מפתחים יכולים לעבוד על אותו פרויקט במקביל ולמזג את עבודתם.
+* **חזרה לגרסאות קודמות:** ניתן לשחזר בקלות כל גרסה קודמת של הפרויקט.
+* **ניהול ענפים (`Branches`):** לפתח פיצ'רים חדשים או לתקן באגים בסביבה מבודדת מבלי להשפיע על הקוד הראשי.
+
+**סוגי Repository:**
+* **מקומי (`Local Repository`):** עותק של המאגר שנמצא על המחשב האישי של המפתח.
+* **מרוחק (`Remote Repository`):** מאגר שנמצא על שרת מרוחק (לדוגמה, ב-**GitHub**, **GitLab**, או **Bitbucket**), ומשמש לגיבוי ולשיתוף בין מפתחים.
+
+## דוגמאות קוד
+
+פקודות בסיסיות ליצירת מאגר **Git** מקומי:
+
+### פייתון (`Python`) - שימוש בספריית `GitPython` (לניהול `Git` מתוך קוד)
+```python
+from git import Repo
+import os
+
+# נניח שזו התיקייה שבה תרצו ליצור את הריפוזיטורי
+repo_path = 'my_new_repo'
+
+# יצירת ריפוזיטורי חדש
+if not os.path.exists(repo_path):
+    os.makedirs(repo_path)
+repo = Repo.init(repo_path)
+print(f"Repository initialized at: {repo.working_dir}")
+
+# הוספת קובץ וביצוע commit
+with open(os.path.join(repo_path, 'hello.txt'), 'w') as f:
+    f.write('Hello, Git!')
+
+repo.index.add(['hello.txt'])
+repo.index.commit("Initial commit: Add hello.txt")
+print("Initial commit created.")
\ No newline at end of file
diff --git a/sites/he/glossary/reset.md b/sites/he/glossary/reset.md
new file mode 100644
index 00000000..e6a441ff
--- /dev/null
+++ b/sites/he/glossary/reset.md
@@ -0,0 +1,201 @@
+# Reset (איפוס מצב המאגר)
+
+**הגדרה קצרה:** פעולה ב-Git המאפשרת לחזור למצב קודם של המאגר, על ידי איפוס ה-HEAD, אזור העבודה (working directory) ו/או אזור ההכנה (staging area) לנקודה ספציפית בהיסטוריה.
+
+## הסבר מורחב
+
+`Reset` (איפוס מצב המאגר) הוא כלי חזק ב-Git שמאפשר לחזור למצב קודם של המאגר. יש שלושה סוגים עיקריים של reset:
+
+1. **Soft Reset** (`--soft`): איפוס ה-HEAD בלבד, שומר שינויים ב-staging area
+2. **Mixed Reset** (`--mixed`, ברירת מחדל): איפוס HEAD ו-staging area, שומר שינויים ב-working directory
+3. **Hard Reset** (`--hard`): איפוס מלא - HEAD, staging area ו-working directory
+
+היתרונות העיקריים של **Reset** הם:
+* **בטיחות:** מאפשר לחזור למצב קודם ללא איבוד מידע.
+* **גמישות:** שלושה סוגי reset שונים למצבים שונים.
+* **ניקוי:** מאפשר לנקות שינויים לא רצויים.
+* **שליטה:** מאפשר לעצב מחדש את ההיסטוריה.
+
+**דוגמאות לשימוש נפוץ:**
+* ביטול התחייבות אחרונה עם שמירת השינויים.
+* ניקוי staging area לפני commit חדש.
+* חזרה למצב נקי לפני ניסוי.
+* ביטול merge או rebase כושל.
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# reset soft - איפוס HEAD בלבד, שומר שינויים ב-staging area
+git reset --soft HEAD~1
+
+# reset mixed (ברירת מחדל) - איפוס HEAD ו-staging area
+git reset HEAD~1
+git reset --mixed HEAD~1
+
+# reset hard - איפוס מלא, מסיר כל השינויים
+git reset --hard HEAD~1
+
+# reset לזיהוי ספציפי
+git reset --hard abc1234
+
+# reset של קובץ ספציפי
+git reset HEAD file.txt
+
+# reset של קובץ ספציפי עם hard
+git reset --hard HEAD file.txt
+
+# reset לזיהוי מרוחק
+git reset --hard origin/main
+
+# reset עם שמירת שינויים כ-stash
+git reset --soft HEAD~1 && git stash
+
+# reset של staging area בלבד
+git reset
+
+# reset עם הודעה על השינויים
+git reset --hard HEAD~1 --quiet
+
+# reset עם אימות
+git reset --hard HEAD~1 --verify-signatures
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+import os
+
+repo = Repo('my_repo')
+
+# reset בסיסי
+def soft_reset(repo, commit_hash):
+    """ביצוע soft reset - איפוס HEAD בלבד"""
+    try:
+        repo.git.reset('--soft', commit_hash)
+        print(f"Soft reset ל-{commit_hash} הושלם בהצלחה")
+        return True
+    except Exception as e:
+        print(f"שגיאה ב-soft reset: {e}")
+        return False
+
+def mixed_reset(repo, commit_hash):
+    """ביצוע mixed reset - איפוס HEAD ו-staging area"""
+    try:
+        repo.git.reset('--mixed', commit_hash)
+        print(f"Mixed reset ל-{commit_hash} הושלם בהצלחה")
+        return True
+    except Exception as e:
+        print(f"שגיאה ב-mixed reset: {e}")
+        return False
+
+def hard_reset(repo, commit_hash):
+    """ביצוע hard reset - איפוס מלא"""
+    try:
+        repo.git.reset('--hard', commit_hash)
+        print(f"Hard reset ל-{commit_hash} הושלם בהצלחה")
+        return True
+    except Exception as e:
+        print(f"שגיאה ב-hard reset: {e}")
+        return False
+
+# reset של קובץ ספציפי
+def reset_file(repo, file_path, hard=False):
+    """איפוס קובץ ספציפי"""
+    try:
+        if hard:
+            repo.git.reset('--hard', 'HEAD', '--', file_path)
+        else:
+            repo.git.reset('HEAD', '--', file_path)
+        print(f"Reset של {file_path} הושלם")
+        return True
+    except Exception as e:
+        print(f"שגיאה ב-reset של {file_path}: {e}")
+        return False
+
+# בדיקת מצב לפני ואחרי reset
+def check_reset_status(repo, commit_hash, reset_type='mixed'):
+    """בדיקת מצב המאגר לפני ואחרי reset"""
+    print(f"מצב לפני {reset_type} reset:")
+    print(f"HEAD: {repo.head.commit.hexsha[:8]}")
+    print(f"Staging area: {len(repo.index.diff('HEAD'))} שינויים")
+    print(f"Working directory: {len(repo.untracked_files)} קבצים לא מנוהלים")
+    
+    try:
+        # ביצוע reset
+        if reset_type == 'soft':
+            repo.git.reset('--soft', commit_hash)
+        elif reset_type == 'hard':
+            repo.git.reset('--hard', commit_hash)
+        else:
+            repo.git.reset('--mixed', commit_hash)
+        
+        print(f"\nמצב אחרי {reset_type} reset:")
+        print(f"HEAD: {repo.head.commit.hexsha[:8]}")
+        print(f"Staging area: {len(repo.index.diff('HEAD'))} שינויים")
+        print(f"Working directory: {len(repo.untracked_files)} קבצים לא מנוהלים")
+        
+    except Exception as e:
+        print(f"שגיאה ב-reset: {e}")
+
+# reset עם גיבוי
+def safe_reset(repo, commit_hash, reset_type='mixed'):
+    """ביצוע reset בטוח עם גיבוי"""
+    try:
+        # יצירת ענף גיבוי
+        backup_branch = f"backup-{repo.head.commit.hexsha[:8]}"
+        repo.git.checkout('-b', backup_branch)
+        
+        # חזרה לענף המקורי
+        repo.git.checkout('-')
+        
+        # ביצוע reset
+        if reset_type == 'soft':
+            repo.git.reset('--soft', commit_hash)
+        elif reset_type == 'hard':
+            repo.git.reset('--hard', commit_hash)
+        else:
+            repo.git.reset('--mixed', commit_hash)
+        
+        print(f"Reset בטוח הושלם. גיבוי נשמר בענף {backup_branch}")
+        return True
+        
+    except Exception as e:
+        print(f"שגיאה ב-reset בטוח: {e}")
+        return False
+
+# דוגמה לשימוש
+if __name__ == "__main__":
+    # בדיקת התחייבויות אחרונות
+    print("התחייבויות אחרונות:")
+    for commit in repo.iter_commits('HEAD', max_count=5):
+        print(f"  {commit.hexsha[:8]} - {commit.message.strip()}")
+    
+    # דוגמה: ביטול התחייבות אחרונה עם שמירת שינויים
+    last_commit = repo.head.commit.parents[0].hexsha
+    if soft_reset(repo, last_commit):
+        print("התחייבות אחרונה בוטלה, השינויים נשמרו ב-staging area")
+    
+    # דוגמה: ניקוי staging area
+    if mixed_reset(repo, 'HEAD'):
+        print("Staging area נוקתה")
+    
+    # דוגמה: reset מלא למצב נקי
+    if hard_reset(repo, 'HEAD'):
+        print("מאגר אופס למצב נקי")
+```
+
+## מונחים קשורים
+
+* [Commit (התחייבות)](./commit.md)
+* [HEAD (ראש המאגר)](./head.md)
+* [Staging Area (אזור ההכנה)](./staging.md)
+* [Working Directory (אזור העבודה)](./working-directory.md)
+* [Stash (שמירה זמנית)](./stash.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על git reset](https://git-scm.com/docs/git-reset)
+* [Git Reset Tutorial](https://git-scm.com/book/en/v2/Git-Tools-Reset-Demystified)
+* [GitPython Documentation](https://gitpython.readthedocs.io/en/stable/reference.html#git.cmd.Git.reset)
+* [Understanding Git Reset](https://git-scm.com/book/en/v2/Git-Tools-Reset-Demystified#_git_reset) 
\ No newline at end of file
diff --git a/sites/he/glossary/staging.md b/sites/he/glossary/staging.md
new file mode 100644
index 00000000..4c174a8a
--- /dev/null
+++ b/sites/he/glossary/staging.md
@@ -0,0 +1,68 @@
+# Staging Area (אזור ההכנה)
+
+**הגדרה קצרה:** אזור ביניים ב-Git שבו נשמרים השינויים שהוכנו ל-commit, לפני שהם נשמרים בהיסטוריה של המאגר.
+
+## הסבר מורחב
+
+`Staging Area` (אזור ההכנה) הוא אזור זמני שבו אתה מכין שינויים לפני commit. זה מאפשר לך לבחור בדיוק איזה שינויים לכלול ב-commit הבא, גם אם יש לך שינויים רבים בקבצים שונים.
+
+**דוגמאות לשימוש נפוץ:**
+* הכנת קבצים ל-commit
+* בחירת שינויים ספציפיים
+* בדיקת מה ייכלל ב-commit
+* ניקוי staging area
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# הוספת קובץ ל-staging area
+git add file.txt
+
+# הוספת כל השינויים
+git add .
+
+# הוספת קבצים לפי pattern
+git add *.js
+
+# הסרת קובץ מ-staging area
+git reset HEAD file.txt
+
+# הצגת מה ב-staging area
+git diff --staged
+
+# ניקוי staging area
+git reset
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+
+repo = Repo('my_repo')
+
+# בדיקת staging area
+def check_staging_area(repo):
+    staged_files = repo.index.diff('HEAD')
+    print(f"קבצים ב-staging area: {len(staged_files)}")
+    
+    for diff in staged_files:
+        print(f"  {diff.a_path}")
+
+# הוספת קובץ ל-staging area
+def stage_file(repo, file_path):
+    repo.index.add([file_path])
+    print(f"נוסף {file_path} ל-staging area")
+
+check_staging_area(repo)
+```
+
+## מונחים קשורים
+
+* [Add (הוספה)](./add.md)
+* [Commit (התחייבות)](./commit.md)
+* [Reset (איפוס)](./reset.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על Staging Area](https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository) 
\ No newline at end of file
diff --git a/sites/he/glossary/stash.md b/sites/he/glossary/stash.md
new file mode 100644
index 00000000..29c1d832
--- /dev/null
+++ b/sites/he/glossary/stash.md
@@ -0,0 +1,113 @@
+ # Stash (שמירה זמנית)
+
+**הגדרה קצרה:** פעולה ב-Git המאפשרת לשמור שינויים זמניים (uncommitted changes) בצד, כדי לנקות את אזור העבודה (working directory) ולאפשר מעבר לענף אחר או ביצוע פעולות אחרות, ולאחר מכן להחזיר את השינויים.
+
+## הסבר מורחב
+
+`Stash` (שמירה זמנית) הוא כלי שימושי ב-Git כאשר יש לך שינויים שעדיין לא התחייבת אליהם, ואתה צריך לעבור לענף אחר או לבצע פעולה אחרת. במקום לבצע commit לא מוכן או לאבד את השינויים, Git מאפשר לך לשמור אותם זמנית ב"מחסנית" (stash).
+
+היתרונות העיקריים של **Stash** הם:
+* **גמישות בעבודה:** מאפשר מעבר מהיר בין ענפים ללא איבוד עבודה.
+* **ניקוי אזור העבודה:** מאפשר לבצע פעולות Git אחרות על מאגר נקי.
+* **שמירה זמנית:** שומר שינויים ללא יצירת commit רשמי.
+* **ניהול שינויים:** מאפשר לחזור לשינויים מאוחר יותר.
+
+**דוגמאות לשימוש נפוץ:**
+* כאשר יש שינויים לא מוכנים ואתה צריך לעבור לענף אחר לתיקון דחוף.
+* כאשר אתה רוצה לבצע pull או merge על מאגר נקי.
+* כאשר אתה רוצה לשמור עבודה זמנית לפני ניסוי או שינוי גדול.
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# שמירה זמנית של כל השינויים
+git stash
+
+# שמירה זמנית עם הודעה מתארת
+git stash push -m "עבודה על פיצ'ר חדש"
+
+# הצגת רשימת השמירות הזמניות
+git stash list
+
+# החזרת השמירה הזמנית האחרונה
+git stash pop
+
+# החזרת שמירה זמנית ספציפית
+git stash apply stash@{1}
+
+# הצגת תוכן השמירה הזמנית
+git stash show stash@{0}
+
+# הצגת diff של השמירה הזמנית
+git stash show -p stash@{0}
+
+# מחיקת שמירה זמנית
+git stash drop stash@{0}
+
+# מחיקת כל השמירות הזמניות
+git stash clear
+
+# שמירה זמנית של קבצים ספציפיים
+git stash push file1.txt file2.txt
+
+# שמירה זמנית כולל קבצים לא מנוהלים (untracked)
+git stash -u
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+import os
+
+repo = Repo('my_repo')
+
+# שמירה זמנית של שינויים
+stash = repo.git.stash()
+
+# שמירה זמנית עם הודעה
+stash = repo.git.stash('push', '-m', 'עבודה על פיצ\'ר חדש')
+
+# הצגת רשימת השמירות הזמניות
+stash_list = repo.git.stash('list')
+print("רשימת שמירות זמניות:")
+for line in stash_list.split('\n'):
+    if line.strip():
+        print(f"  {line}")
+
+# החזרת השמירה הזמנית האחרונה
+repo.git.stash('pop')
+
+# החזרת שמירה זמנית ספציפית
+repo.git.stash('apply', 'stash@{1}')
+
+# בדיקת מצב המאגר לפני ואחרי stash
+print("מצב לפני stash:")
+print(repo.git.status())
+
+# שמירה זמנית
+repo.git.stash()
+
+print("מצב אחרי stash:")
+print(repo.git.status())
+
+# החזרת השמירה הזמנית
+repo.git.stash('pop')
+
+print("מצב אחרי החזרת stash:")
+print(repo.git.status())
+```
+
+## מונחים קשורים
+
+* [Commit (התחייבות)](./commit.md)
+* [Branch (ענף)](./branch.md)
+* [Checkout (מעבר)](./checkout.md)
+* [Status (מצב)](./status.md)
+* [Diff (הבדלים)](./diff.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על git stash](https://git-scm.com/docs/git-stash)
+* [Git Stash Tutorial](https://git-scm.com/book/en/v2/Git-Tools-Stashing-and-Cleaning)
+* [GitPython Documentation](https://gitpython.readthedocs.io/en/stable/reference.html#git.cmd.Git.stash)
\ No newline at end of file
diff --git a/sites/he/glossary/status.md b/sites/he/glossary/status.md
new file mode 100644
index 00000000..83e234ec
--- /dev/null
+++ b/sites/he/glossary/status.md
@@ -0,0 +1,237 @@
+ # Status (בדיקת מצב המאגר)
+
+**הגדרה קצרה:** פקודה ב-Git המציגה את המצב הנוכחי של המאגר, כולל מידע על קבצים שעברו שינויים, קבצים שהוכנו ל-commit, וקבצים שלא מנוהלים על ידי Git.
+
+## הסבר מורחב
+
+`Status` (בדיקת מצב המאגר) הוא אחד הפקודות החשובות ביותר ב-Git שמאפשרת לך לראות את המצב הנוכחי של המאגר. הפקודה מציגה מידע על:
+
+* **קבצים שעברו שינויים** (modified files)
+* **קבצים שהוכנו ל-commit** (staged files)
+* **קבצים שלא מנוהלים** (untracked files)
+* **קבצים שנמחקו** (deleted files)
+* **ענף נוכחי** (current branch)
+* **מצב ביחס לענף מרוחק** (ahead/behind)
+
+היתרונות העיקריים של **Status** הם:
+* **סקירה מהירה:** מאפשר לראות במבט אחד מה השתנה במאגר.
+* **תכנון:** עוזר לתכנן את השלבים הבאים בעבודה.
+* **דיבוג:** עוזר להבין למה דברים לא עובדים כמצופה.
+* **בטיחות:** מאפשר לוודא שהכל בסדר לפני commit.
+
+**דוגמאות לשימוש נפוץ:**
+* בדיקת מה השתנה לפני commit.
+* וידוא שכל הקבצים הנכונים הוכנו ל-commit.
+* בדיקת מצב ביחס לענף מרוחק.
+* זיהוי קבצים שלא מנוהלים על ידי Git.
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# הצגת מצב בסיסי
+git status
+
+# הצגת מצב בקיצור
+git status --short
+git status -s
+
+# הצגת מצב עם פירוט מלא
+git status --verbose
+
+# הצגת מצב עם קבצים לא מנוהלים
+git status --ignored
+
+# הצגת מצב עם קבצים שנמחקו
+git status --porcelain
+
+# הצגת מצב עם פורמט JSON
+git status --porcelain=2
+
+# הצגת מצב עם קבצים ספציפיים
+git status file1.txt file2.txt
+
+# הצגת מצב עם קבצים בתיקיה
+git status src/
+
+# הצגת מצב עם קבצים שתאמו ל-pattern
+git status "*.js"
+
+# הצגת מצב עם קבצים שתאמו ל-pattern (recursive)
+git status "**/*.js"
+
+# הצגת מצב עם קבצים שתאמו ל-pattern (case insensitive)
+git status -i "*.TXT"
+
+# הצגת מצב עם קבצים שתאמו ל-pattern (exclude)
+git status --exclude="*.log"
+
+# הצגת מצב עם קבצים שתאמו ל-pattern (include)
+git status --include="*.py"
+
+# הצגת מצב עם קבצים שתאמו ל-pattern (exclude from .gitignore)
+git status --ignored --exclude="*.tmp"
+
+# הצגת מצב עם קבצים שתאמו ל-pattern (include from .gitignore)
+git status --ignored --include="*.pyc"
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+import os
+
+repo = Repo('my_repo')
+
+# הצגת מצב בסיסי
+def show_basic_status(repo):
+    """הצגת מצב בסיסי של המאגר"""
+    print("מצב המאגר:")
+    print(f"ענף נוכחי: {repo.active_branch.name}")
+    print(f"HEAD: {repo.head.commit.hexsha[:8]}")
+    
+    # בדיקת שינויים
+    if repo.is_dirty():
+        print("יש שינויים במאגר")
+    else:
+        print("המאגר נקי")
+
+# הצגת מצב מפורט
+def show_detailed_status(repo):
+    """הצגת מצב מפורט של המאגר"""
+    print("מצב מפורט:")
+    
+    # קבצים שהוכנו ל-commit
+    staged_files = repo.index.diff('HEAD')
+    if staged_files:
+        print("\nקבצים שהוכנו ל-commit:")
+        for diff in staged_files:
+            print(f"  + {diff.a_path}")
+    
+    # קבצים שעברו שינויים
+    unstaged_files = repo.index.diff(None)
+    if unstaged_files:
+        print("\nקבצים שעברו שינויים:")
+        for diff in unstaged_files:
+            print(f"  M {diff.a_path}")
+    
+    # קבצים שלא מנוהלים
+    untracked_files = repo.untracked_files
+    if untracked_files:
+        print("\nקבצים שלא מנוהלים:")
+        for file in untracked_files:
+            print(f"  ? {file}")
+
+# בדיקת מצב של קובץ ספציפי
+def check_file_status(repo, file_path):
+    """בדיקת מצב של קובץ ספציפי"""
+    try:
+        # בדיקה אם הקובץ קיים
+        if not os.path.exists(file_path):
+            print(f"קובץ {file_path} לא קיים")
+            return
+        
+        # בדיקת מצב הקובץ
+        if file_path in repo.untracked_files:
+            print(f"{file_path}: לא מנוהל")
+        elif file_path in [diff.a_path for diff in repo.index.diff('HEAD')]:
+            print(f"{file_path}: הוכן ל-commit")
+        elif file_path in [diff.a_path for diff in repo.index.diff(None)]:
+            print(f"{file_path}: עבר שינויים")
+        else:
+            print(f"{file_path}: לא השתנה")
+            
+    except Exception as e:
+        print(f"שגיאה בבדיקת מצב {file_path}: {e}")
+
+# הצגת סטטיסטיקות מצב
+def show_status_stats(repo):
+    """הצגת סטטיסטיקות מצב המאגר"""
+    print("סטטיסטיקות מצב:")
+    
+    # ספירת קבצים שהוכנו
+    staged_count = len(repo.index.diff('HEAD'))
+    print(f"קבצים שהוכנו ל-commit: {staged_count}")
+    
+    # ספירת קבצים שעברו שינויים
+    unstaged_count = len(repo.index.diff(None))
+    print(f"קבצים שעברו שינויים: {unstaged_count}")
+    
+    # ספירת קבצים שלא מנוהלים
+    untracked_count = len(repo.untracked_files)
+    print(f"קבצים שלא מנוהלים: {untracked_count}")
+    
+    # בדיקת מצב ביחס לענף מרוחק
+    try:
+        ahead, behind = repo.count_commits()
+        if ahead > 0:
+            print(f"מקדים את הענף המרוחק ב-{ahead} התחייבויות")
+        if behind > 0:
+            print(f"מפגר אחרי הענף המרוחק ב-{behind} התחייבויות")
+    except:
+        print("לא ניתן לבדוק מצב ביחס לענף מרוחק")
+
+# בדיקת מצב עם פילטרים
+def show_filtered_status(repo, file_pattern=None, include_ignored=False):
+    """הצגת מצב עם פילטרים"""
+    print("מצב עם פילטרים:")
+    
+    if file_pattern:
+        print(f"פילטר: {file_pattern}")
+    
+    # קבצים שהוכנו
+    staged_files = [f for f in repo.index.diff('HEAD') 
+                   if not file_pattern or file_pattern in f.a_path]
+    if staged_files:
+        print("\nקבצים שהוכנו:")
+        for diff in staged_files:
+            print(f"  + {diff.a_path}")
+    
+    # קבצים שעברו שינויים
+    unstaged_files = [f for f in repo.index.diff(None) 
+                     if not file_pattern or file_pattern in f.a_path]
+    if unstaged_files:
+        print("\nקבצים שעברו שינויים:")
+        for diff in unstaged_files:
+            print(f"  M {diff.a_path}")
+    
+    # קבצים שלא מנוהלים
+    untracked_files = [f for f in repo.untracked_files 
+                      if not file_pattern or file_pattern in f]
+    if untracked_files:
+        print("\nקבצים שלא מנוהלים:")
+        for file in untracked_files:
+            print(f"  ? {file}")
+
+# דוגמה לשימוש
+if __name__ == "__main__":
+    # הצגת מצב בסיסי
+    show_basic_status(repo)
+    
+    # הצגת מצב מפורט
+    show_detailed_status(repo)
+    
+    # הצגת סטטיסטיקות
+    show_status_stats(repo)
+    
+    # בדיקת מצב של קובץ ספציפי
+    check_file_status(repo, "README.md")
+    
+    # הצגת מצב עם פילטר
+    show_filtered_status(repo, ".py")
+```
+
+## מונחים קשורים
+
+* [Working Directory (אזור העבודה)](./working-directory.md)
+* [Staging Area (אזור ההכנה)](./staging.md)
+* [Commit (התחייבות)](./commit.md)
+* [Add (הוספה)](./add.md)
+* [Diff (הבדלים)](./diff.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על git status](https://git-scm.com/docs/git-status)
+* [Git Status Tutorial](https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository)
+* [GitPython Documentation](https://gitpython.readthedocs.io/en/stable/reference.html#git.repo.base.Repo.is_dirty)
+* [Understanding Git Status](https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository#_checking_status)
\ No newline at end of file
diff --git a/sites/he/glossary/submodule.md b/sites/he/glossary/submodule.md
new file mode 100644
index 00000000..f45d07d5
--- /dev/null
+++ b/sites/he/glossary/submodule.md
@@ -0,0 +1,159 @@
+ # Submodule (מודול משנה)
+
+**הגדרה קצרה:** מאגר Git נפרד שמשולב בתוך מאגר Git אחר, מאפשר שימוש בקוד חיצוני תוך שמירה על היסטוריה נפרדת ועדכונים נפרדים.
+
+## הסבר מורחב
+
+`Submodule` (מודול משנה) הוא מאגר Git נפרד שמשולב בתוך מאגר Git אחר. זה מאפשר לך להשתמש בקוד חיצוני (כמו ספריות, כלים או פרויקטים אחרים) תוך שמירה על היסטוריה נפרדת ועדכונים נפרדים.
+
+היתרונות העיקריים של **Submodule** הם:
+* **שימוש חוזר בקוד:** מאפשר להשתמש באותו קוד בפרויקטים שונים.
+* **היסטוריה נפרדת:** כל submodule שומר על ההיסטוריה שלו.
+* **עדכונים נפרדים:** ניתן לעדכן כל submodule בנפרד.
+* **גמישות:** מאפשר לשלב פרויקטים חיצוניים בקלות.
+
+**דוגמאות לשימוש נפוץ:**
+* שילוב ספריות חיצוניות בפרויקט.
+* שימוש בכלים או סקריפטים משותפים.
+* שילוב פרויקטים קטנים בפרויקט גדול.
+* שימוש בקוד משותף בין צוותים.
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# הוספת submodule
+git submodule add https://github.com/user/library.git libs/library
+
+# הוספת submodule עם ענף ספציפי
+git submodule add -b develop https://github.com/user/library.git libs/library
+
+# שכפול מאגר עם submodules
+git clone --recursive https://github.com/user/project.git
+
+# שכפול submodules אחרי clone
+git submodule update --init --recursive
+
+# עדכון submodule לגרסה אחרונה
+git submodule update --remote
+
+# מעבר לתיקיית submodule
+cd libs/library
+git checkout main
+git pull origin main
+cd ../..
+
+# עדכון submodule במאגר הראשי
+git add libs/library
+git commit -m "עדכון submodule"
+
+# הסרת submodule
+git submodule deinit libs/library
+git rm libs/library
+git commit -m "הסרת submodule"
+
+# הצגת רשימת submodules
+git submodule status
+
+# הצגת רשימת submodules עם פרטים
+git submodule foreach 'git status'
+
+# עדכון כל submodules
+git submodule foreach 'git pull origin main'
+
+# שכפול submodule ספציפי
+git submodule update --init libs/library
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+import os
+
+repo = Repo('my_repo')
+
+# הוספת submodule
+def add_submodule(repo, url, path):
+    """הוספת submodule חדש"""
+    try:
+        repo.git.submodule('add', url, path)
+        print(f"נוסף submodule {path} מ-{url}")
+        return True
+    except Exception as e:
+        print(f"שגיאה בהוספת submodule: {e}")
+        return False
+
+# עדכון submodules
+def update_submodules(repo):
+    """עדכון כל submodules"""
+    try:
+        repo.git.submodule('update', '--init', '--recursive')
+        print("כל submodules עודכנו")
+        return True
+    except Exception as e:
+        print(f"שגיאה בעדכון submodules: {e}")
+        return False
+
+# הצגת רשימת submodules
+def list_submodules(repo):
+    """הצגת רשימת submodules"""
+    try:
+        submodules = repo.submodules
+        print("רשימת submodules:")
+        for submodule in submodules:
+            print(f"  {submodule.name}: {submodule.url}")
+        return submodules
+    except Exception as e:
+        print(f"שגיאה בהצגת submodules: {e}")
+        return []
+
+# עדכון submodule ספציפי
+def update_specific_submodule(repo, submodule_name):
+    """עדכון submodule ספציפי"""
+    try:
+        repo.git.submodule('update', '--remote', submodule_name)
+        print(f"Submodule {submodule_name} עודכן")
+        return True
+    except Exception as e:
+        print(f"שגיאה בעדכון {submodule_name}: {e}")
+        return False
+
+# בדיקת מצב submodules
+def check_submodule_status(repo):
+    """בדיקת מצב submodules"""
+    try:
+        status = repo.git.submodule('status')
+        print("מצב submodules:")
+        print(status)
+        return status
+    except Exception as e:
+        print(f"שגיאה בבדיקת מצב: {e}")
+        return None
+
+# דוגמה לשימוש
+if __name__ == "__main__":
+    # הוספת submodule
+    add_submodule(repo, "https://github.com/user/library.git", "libs/library")
+    
+    # הצגת רשימת submodules
+    submodules = list_submodules(repo)
+    
+    # עדכון submodules
+    update_submodules(repo)
+    
+    # בדיקת מצב
+    check_submodule_status(repo)
+```
+
+## מונחים קשורים
+
+* [Repository (מאגר)](./repository.md)
+* [Clone (שכפול)](./clone.md)
+* [Remote (מרוחק)](./remote.md)
+* [Commit (התחייבות)](./commit.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על git submodule](https://git-scm.com/docs/git-submodule)
+* [Git Submodules Tutorial](https://git-scm.com/book/en/v2/Git-Tools-Submodules)
+* [GitPython Documentation](https://gitpython.readthedocs.io/en/stable/reference.html#git.repo.base.Repo.submodules)
\ No newline at end of file
diff --git a/sites/he/glossary/tag.md b/sites/he/glossary/tag.md
new file mode 100644
index 00000000..209149d0
--- /dev/null
+++ b/sites/he/glossary/tag.md
@@ -0,0 +1,62 @@
+ # Tag (תגית)
+
+**הגדרה קצרה:** תגית היא סימון נקודתי בהיסטוריית המאגר (repository) במערכת ניהול גרסאות כמו **Git**, המשמשת בדרך כלל לסימון גרסאות חשובות (למשל: שחרור גרסה v1.0.0).
+
+## הסבר מורחב
+
+`Tag` (תגית) מאפשרת לסמן commit מסוים כנקודת ציון חשובה, כמו שחרור גרסה, milestone, או כל אירוע משמעותי אחר בפרויקט. התגיות ב-Git הן "קלות משקל" (lightweight) או "מועשרות" (annotated), כאשר Annotated Tag כוללת מידע נוסף כמו שם יוצר התגית, תאריך, וחתימה דיגיטלית. התגיות אינן משתנות – הן תמיד מצביעות לאותו commit, גם אם ההיסטוריה משתנה.
+
+היתרונות העיקריים של **Tag** הם:
+* **סימון גרסאות:** מאפשר לחזור בקלות לגרסה מסוימת של הפרויקט.
+* **שחרור גרסאות:** נהוג להוציא Release על בסיס תגית.
+* **מעקב אחר נקודות ציון:** סימון milestones חשובים בפרויקט.
+
+**דוגמאות לשימוש נפוץ:**
+* יצירת תגית לגרסה חדשה: `git tag v1.0.0`
+* יצירת תגית Annotated: `git tag -a v1.0.0 -m "גרסה ראשונה"`
+* דחיפת תגיות למאגר מרוחק: `git push origin v1.0.0`
+* הצגת כל התגיות: `git tag`
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# יצירת תגית קלה (lightweight)
+git tag v1.0.0
+
+# יצירת תגית Annotated עם הודעה
+git tag -a v1.0.0 -m "גרסה ראשונה"
+
+# דחיפת כל התגיות למאגר מרוחק
+git push --tags
+
+# דחיפת תגית בודדת
+git push origin v1.0.0
+
+# הצגת כל התגיות
+git tag
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+repo = Repo('my_repo')
+# יצירת תגית קלה
+repo.create_tag('v1.0.0')
+# יצירת תגית Annotated
+repo.create_tag('v1.0.1', message='גרסה שניה')
+# הצגת כל התגיות
+for tag in repo.tags:
+    print(tag)
+```
+
+## מונחים קשורים
+
+* [Commit (התחייבות)](./commit.md)
+* [Release (גרסה)](./release.md)
+* [Branch (ענף)](./branch.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על Tag](https://git-scm.com/docs/git-tag)
+* [הסבר על Tag ב-GitHub Docs](https://docs.github.com/en/get-started/quickstart/github-glossary#tag)
diff --git a/sites/he/glossary/working-directory.md b/sites/he/glossary/working-directory.md
new file mode 100644
index 00000000..04dfb480
--- /dev/null
+++ b/sites/he/glossary/working-directory.md
@@ -0,0 +1,59 @@
+# Working Directory (אזור העבודה)
+
+**הגדרה קצרה:** התיקיה במערכת הקבצים שבה אתה עובד כרגע, המכילה את כל הקבצים הנוכחיים של המאגר ואת השינויים שעשית.
+
+## הסבר מורחב
+
+`Working Directory` (אזור העבודה) הוא התיקיה במחשב שלך שבה נמצאים כל הקבצים של המאגר. זה המקום שבו אתה עורך קבצים, מוסיף קבצים חדשים, או מוחק קבצים קיימים.
+
+**דוגמאות לשימוש נפוץ:**
+* עריכת קבצים קיימים
+* הוספת קבצים חדשים
+* מחיקת קבצים
+* בדיקת מצב השינויים
+
+## דוגמת קוד
+
+### פקודות Git בטרמינל
+```bash
+# הצגת תוכן אזור העבודה
+ls -la
+
+# בדיקת מצב השינויים
+git status
+
+# הצגת הבדלים באזור העבודה
+git diff
+
+# ניקוי אזור העבודה (זהירות!)
+git clean -fd
+```
+
+### פייתון (שימוש בספריית GitPython)
+```python
+from git import Repo
+import os
+
+repo = Repo('my_repo')
+
+# בדיקת אזור העבודה
+def check_working_directory(repo):
+    print(f"אזור העבודה: {repo.working_dir}")
+    print(f"קבצים שעברו שינויים: {len(repo.untracked_files)}")
+    
+    # הצגת קבצים לא מנוהלים
+    for file in repo.untracked_files:
+        print(f"  לא מנוהל: {file}")
+
+check_working_directory(repo)
+```
+
+## מונחים קשורים
+
+* [Staging Area (אזור ההכנה)](./staging.md)
+* [Status (מצב)](./status.md)
+* [Diff (הבדלים)](./diff.md)
+
+## מקורות מידע נוספים
+
+* [תיעוד Git על Working Directory](https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository) 
\ No newline at end of file