Git Local Ignore: Ignore Files Without Global Config

To ignore files locally without affecting your global Git configuration, you have two primary methods: using the .git/info/exclude file for untracked files or using git update-index --skip-worktree for already tracked files. The .git/info/exclude approach is ideal for files that should never be tracked, while skip-worktree helps when you need to ignore local changes to files that are already tracked.

Contents

• Understanding Git Ignore Files
• Method 1: Using .git/info/exclude for Local Exclusions
• Method 2: Using git update-index --skip-worktree for Tracked Files
• Comparing Local vs. Repository vs. Global Ignore Files
• Practical Examples and Workflows
• Troubleshooting Common Issues

Understanding Git Ignore Files

Git provides multiple levels of file ignoring that serve different purposes. Understanding these levels helps you choose the right approach for your specific needs:

• Global ignore file: Configured via core.excludesFile in your global Git config, affects all repositories on your system
• Repository ignore file (.gitignore): Placed in the repository root, shared with all collaborators
• Local exclude file (.git/info/exclude): Specific to your local repository, not shared with others

The key advantage of local exclusion methods is that they don’t affect other team members or require changes to the repository structure.

Method 1: Using .git/info/exclude for Local Exclusions

The .git/info/exclude file is Git’s built-in mechanism for local file exclusions that aren’t shared with collaborators. This is perfect for handling untracked files that appear as spam in your Git status.

Creating and Using .git/info/exclude

1. Navigate to your repository’s .git/info directory:

   bash

   cd /path/to/your/repository
   touch .git/info/exclude
   

2. Add patterns to exclude files:

   bash

   echo "# Local exclusions - not shared with repository" >> .git/info/exclude
   echo "*.log" >> .git/info/exclude
   echo "temp/" >> .git/info/exclude
   echo ".DS_Store" >> .git/info/exclude
   

3. Verify the exclusions work:

   bash

   git status
   

Key Features of .git/info/exclude

• Repository-specific: Only affects the current repository
• Not tracked: Changes to this file don’t appear in Git status
• Uses standard gitignore patterns: Supports wildcards, negation, and directory patterns
• No configuration needed: Works immediately after creating the file

Common Use Cases

• IDE temporary files (.vscode/, .idea/)
• OS-specific files (.DS_Store, Thumbs.db)
• Local build artifacts (build/, dist/)
• Log files (*.log, logs/)
• Development-specific configurations

Method 2: Using git update-index --skip-worktree for Tracked Files

When you have files that are already tracked but you want to ignore local changes, git update-index --skip-worktree is the solution. This is different from exclusion because it doesn’t prevent the file from being tracked—it just hides local modifications.

Basic Usage

# Mark a file to ignore local changes
git update-index --skip-worktree path/to/config.local

# Check which files have skip-worktree enabled
git ls-files -v | grep ^S

# Remove skip-worktree flag
git update-index --no-skip-worktree path/to/config.local

Creating Aliases for Convenience

Add these to your ~/.gitconfig for easier use:

[alias]
    # Mark file as skip-worktree
    skip = update-index --skip-worktree
    # Remove skip-worktree flag
    unskip = update-index --no-skip-worktree
    # List files with skip-worktree enabled
    skipped = "!git ls-files -v | grep ^S"

When to Use skip-worktree

• Configuration files that need local customization
• Build artifacts that should remain in version control
• Files that change frequently locally but shouldn’t trigger warnings
• When you need to temporarily ignore changes during development

Comparing Local vs. Repository vs. Global Ignore Files

Choosing the Right Method

Use .git/info/exclude when:

• Files should never be tracked
• You don’t want to affect other team members
• The exclusions are development environment specific

Use skip-worktree when:

• Files are already tracked but need local customization
• You want to preserve file history while ignoring local changes
• The files should remain in version control

Avoid repository .gitignore when:

• Files are personal and shouldn’t be shared
• You don’t want to affect other collaborators’ workflows

Practical Examples and Workflows

Example 1: Handling IDE Files

Problem: Visual Studio Code and IntelliJ IDEA create project-specific files that clutter Git status.

Solution using .git/info/exclude:

# Create local exclusions
cat > .git/info/exclude << EOF
# IDE files - local only
.vscode/
.idea/
*.swp
*.swo
EOF

Example 2: Local Configuration Files

Problem: You have a config.json file that needs local modifications but must remain in version control.

Solution using skip-worktree:

# Mark config.json for local ignore
git update-index --skip-worktree config.json

# Make local changes
echo '{"local": "value"}' > config.json

# Check status - should show clean
git status

# When ready to sync with remote
git update-index --no-skip-worktree config.json
git add config.json

Example 3: Build Artifacts in Version Control

Problem: Your project requires certain build artifacts to be committed, but they clutter your working directory during development.

Solution using skip-worktree:

# Skip local changes to build artifacts
git update-index --skip-worktree build/app.min.js
git update-index --skip-worktree dist/

# Development proceeds without build file warnings
# When ready to commit changes
git update-index --no-skip-worktree build/app.min.js
git add build/app.min.js

Example 4: Automated Script for Common Exclusions

Create a script to set up common local exclusions:

#!/bin/bash
# setup-local-excludes.sh

cat > .git/info/exclude << EOF
# Local development exclusions
# Generated on $(date)

# OS files
.DS_Store
Thumbs.db

# Editor files
.vscode/
.idea/
*.swp
*.swo

# Development artifacts
node_modules/
*.log
temp/
tmp/

# Local configurations
*.local
config.local
EOF

echo "Local exclusions created in .git/info/exclude"
git status

Troubleshooting Common Issues

Files Still Showing in Git Status

Problem: Added patterns to .git/info/exclude but files still appear.

Solutions:

1. Check file location: Ensure patterns match exact file paths
2. Verify syntax: Use standard gitignore patterns
3. Check existing tracking: If files are already tracked, use skip-worktree instead

# Check if files are already tracked
git ls-files | grep "problem-file"

# If tracked, use skip-worktree
git update-index --skip-worktree problem-file

Skip-Worktree Not Working

Problem: Files marked with skip-worktree still show as modified.

Solutions:

1. Verify flags: Check current status with git ls-files -v | grep ^S
2. Reset changes: Use git checkout -- file to reset to tracked version
3. Check merge conflicts: Skip-worktree doesn’t work with merge conflicts

# List skip-worktree files
git ls-files -v | grep ^S

# Reset a file that's causing issues
git checkout -- file.txt
git update-index --skip-worktree file.txt

Conflicts Between Different Ignore Levels

Problem: Files are being ignored at multiple levels causing confusion.

Solution: Understand the ignore precedence:

1. .git/info/exclude (highest priority for local exclusions)
2. .gitignore (repository level)
3. Global ignore file (lowest priority)

Use git check-ignore -v filename to see which rule is applying.

Performance Impact

Problem: Local exclusions causing performance issues.

Solutions:

1. Keep patterns specific: Avoid overly broad patterns
2. Use skip-worktree for tracked files: More efficient than re-excluding
3. Regular maintenance: Remove unnecessary exclusions periodically

Sources

1. How do I configure git to ignore some files locally? - Stack Overflow
2. Git - gitignore Documentation
3. How Do I Configure Git to Ignore Some Local Files? - Better Stack Community
4. Git Tutorial => Ignore files locally without committing ignore rules
5. Git update-index --skip-worktree, and how I used to hate config files - compiled successfully
6. Git Tips — Ignoring local changes in versioned files using Skip-Worktree - Medium
7. .gitignore file - ignoring files in Git - Atlassian Git Tutorial
8. Ignoring files - GitHub Docs

Conclusion

Ignoring files locally without affecting global configuration is essential for maintaining a clean development environment while respecting team workflows. The two primary methods serve distinct purposes:

• Use .git/info/exclude for files that should never be tracked and are specific to your development environment. This is ideal for IDE files, OS artifacts, and temporary files that clutter your Git status.

• Use git update-index --skip-worktree for files that are already tracked but need local customization. This approach preserves file history while allowing local modifications without triggering Git warnings.

By choosing the appropriate method for each scenario, you can maintain a clean working directory without compromising collaboration or repository integrity. Remember that local exclusions never affect other team members, making them safe for personal development preferences and environment-specific files.