# How to Ignore Files Already Tracked by Git: A Complete Guide to Stopping Version Control

> Stop Git from tracking files. Learn how to ignore already tracked files by removing them from the index and updating your gitignore file.

- Repository: [GitHub/gitignore](https://github.com/github/gitignore)
- Tags: how-to-guide
- Published: 2026-02-24

---

**To ignore files already tracked by Git, you must remove them from the index using `git rm --cached <file>`, commit the change, and then add the appropriate pattern to your `.gitignore` file.**

The `github/gitignore` repository provides templates designed to prevent untracked files from entering your repository, but these rules do not affect files already committed to history. Understanding how to properly stop tracking files that were previously added is essential for maintaining clean repositories and protecting sensitive data.

## Why .gitignore Cannot Ignore Already Tracked Files

According to the `github/gitignore` repository's [`README.md`](https://github.com/github/gitignore/blob/main/README.md), Git's ignore mechanism operates exclusively on files that are not already being tracked. As documented in lines 7-13 of the README, adding a file pattern to `.gitignore` will prevent Git from tracking new files that match the pattern, but it will not remove or ignore files that already exist in the repository's index.

This behavior means that simply copying a template from the repository—such as `Node.gitignore` or `Python.gitignore`—into your project will not stop Git from tracking files you previously committed. You must explicitly remove those files from the index first.

## How to Stop Tracking Files Already in the Repository

To properly ignore files already tracked by Git, follow this three-step workflow:

1. **Remove the file from the index** while preserving it in your working directory.

2. **Commit the removal** to record the change in your project history.

3. **Add an ignore pattern** to ensure Git does not track the file in future operations.

Here is the complete command sequence:

```bash

# Remove the file from the index but keep it on disk

git rm --cached <path/to/file>

# Commit the change

git commit -m "Stop tracking <file>: add to .gitignore"

# Add the pattern to .gitignore to prevent future tracking

echo "<file>" >> .gitignore

```

For example, to stop tracking a `.env` file that was accidentally committed:

```bash
echo ".env" >> .gitignore
git rm --cached .env
git commit -m "Remove .env from repository and ignore it in future"

```

You can verify the file is no longer tracked by running:

```bash
git ls-files --stage | grep ".env"

```

This command should return no results, confirming the file has been removed from the index.

## Local-Only Alternatives: assume-unchanged and skip-worktree

If you need to keep a file tracked in the repository but ignore local modifications on your specific machine—such as for personal configuration files—Git provides two index flags that operate locally without affecting the remote repository or other collaborators.

**`--assume-unchanged`** tells Git to treat the file as unchanged regardless of working directory modifications:

```bash
git update-index --assume-unchanged <path/to/file>

```

To resume tracking changes:

```bash
git update-index --no-assume-unchanged <path/to/file>

```

**`--skip-worktree`** is similar but intended for scenarios where you want Git to pretend it does not see changes, effectively using the upstream version while keeping your local modifications:

```bash
git update-index --skip-worktree <path/to/file>

```

Both commands affect only your local clone; other contributors will continue to see and modify the original version of the file.

## Using github/gitignore Templates After Removing Files

Once you have removed previously tracked files from the index using `git rm --cached`, you should populate your `.gitignore` with appropriate patterns to prevent accidental re-addition. The `github/gitignore` repository contains ready-made templates for numerous languages and tools.

You can copy relevant sections from language-specific templates—such as [`Global/README.md`](https://github.com/github/gitignore/blob/main/Global/README.md) for global ignore rules or `Python.gitignore` for Python projects—into your project's `.gitignore` file. The `Global` folder contains patterns for operating systems and editors that you might want to apply across all repositories on your machine.

## Summary

- **`.gitignore` only affects untracked files** and cannot stop Git from tracking files already committed to the repository, as documented in [`README.md`](https://github.com/github/gitignore/blob/main/README.md).
- **Use `git rm --cached`** to remove files from the index while preserving them in your working directory.
- **Always commit the removal** to record the change in your project history.
- **Apply `--assume-unchanged` or `--skip-worktree`** when you need to ignore local modifications without removing the file from the repository.
- **Reference `github/gitignore` templates** after cleaning your index to prevent future tracking issues.

## Frequently Asked Questions

### What is the difference between `git rm --cached` and `git rm`?

`git rm --cached <file>` removes the file from Git's index but keeps it in your working directory, allowing you to ignore it going forward. `git rm <file>` (without the `--cached` flag) deletes the file from both the index and your working directory, effectively removing it from your disk entirely.

### Can I use `.gitignore` to ignore a file that is already committed?

No. According to the `github/gitignore` repository's documentation in [`README.md`](https://github.com/github/gitignore/blob/main/README.md), Git's ignore rules only apply to files that are not already being tracked. Once a file has been committed to the repository, you must first remove it from the index using `git rm --cached` before `.gitignore` patterns will take effect.

### What is the difference between `--assume-unchanged` and `--skip-worktree`?

The `--assume-unchanged` flag tells Git to assume the file matches the version in the index and not to check for modifications, which improves performance for files that change slowly. The `--skip-worktree` flag tells Git to pretend the file does not have local modifications and to use the version from the index instead, effectively allowing you to keep local changes without committing them. Both flags operate only on your local clone.

### Where can I find templates for common ignore patterns?

The `github/gitignore` repository provides comprehensive templates in its root directory and `Global` folder. Language-specific templates like `Node.gitignore` and `Python.gitignore` cover project dependencies, while [`Global/README.md`](https://github.com/github/gitignore/blob/main/Global/README.md) explains how to set up global ignore files that apply across all repositories on your machine.