# How to Ignore Compiled Output Files Like .class, .o, .exe, and .pyc Using GitHub's gitignore Templates

> Learn how to ignore compiled output files like .class .o .exe and .pyc in Git. Use GitHub's gitignore templates to keep your repository clean and focused on source code.

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

---

**To ignore compiled output files in Git, copy the relevant patterns from the official language-specific templates in the `github/gitignore` repository—such as `Java.gitignore` for `.class` files, `C.gitignore` for `.o` objects, and `Python.gitignore` for `.pyc` bytecode—into your project's root `.gitignore` file.**

The `github/gitignore` repository maintains authoritative templates that catalog every common build artefact generated by compilers and build systems. Instead of manually researching which files to exclude, you can reference these community-maintained templates to ensure compiled outputs never reach your version control history.

## Locating Templates for Specific Compiled Outputs

The repository organizes ignore patterns by programming language and operating system. Each template contains precise glob patterns targeting compiler-generated files at specific line numbers.

### Java, Kotlin, and Scala Bytecode

For JVM-based languages, compiled bytecode appears as `.class` files. In `Java.gitignore`, line 2 explicitly defines the pattern:

```gitignore
*.class

```

The same pattern appears in `Kotlin.gitignore` (line 2) and `Scala.gitignore` (line 1), ensuring coverage for all JVM language ecosystems.

### C and C++ Object Files

Native compilation produces intermediate object files before linking. The `C.gitignore` template lists these at line 32:

```gitignore
*.o
*.obj

```

Similarly, `C++.gitignore` includes these patterns at line 38, along with additional C++-specific build artefacts. These rules handle object files generated by GCC, Clang, and MSVC compilers.

### Windows Executables

For Windows development environments, compiled binaries carry `.exe` and `.dll` extensions. The `Global/Windows.gitignore` template provides these patterns at line 4:

```gitignore
*.exe
*.dll

```

Additionally, `VisualStudio.gitignore` (line 343) contains comprehensive Windows binary exclusions for Visual Studio project outputs.

### Python Bytecode

Python interpreters compile source files to bytecode cached as `.pyc` files and `__pycache__` directories. The `Python.gitignore` template defines these exclusions at line 4:

```gitignore
*.pyc
__pycache__/

```

## Implementing Ignore Patterns in Your Project

You have two approaches for integrating these templates: selective copying for minimal configurations or full template inclusion for comprehensive coverage.

### Minimal Combined Approach

For polyglot projects, concatenate only the specific patterns you need into a single `.gitignore` file:

```gitignore

# Java byte-code (from Java.gitignore line 2)

*.class

# C / C++ object files (from C.gitignore line 32)

*.o
*.obj

# Windows executables (from Global/Windows.gitignore line 4)

*.exe

# Python compiled files (from Python.gitignore line 4)

*.pyc
__pycache__/

```

### Full Template Approach

For single-language projects, copy the entire template content to ensure you capture all edge cases, including secondary build artefacts like `.jar` files for Java or `.so` files for C:

```gitignore

# ==================== Java ====================

# https://github.com/github/gitignore/blob/main/Java.gitignore

*.class
*.jar
*.war
*.ear

# ==================== C / C++ ====================

# https://github.com/github/gitignore/blob/main/C.gitignore

*.o
*.obj
*.so
*.dylib

# https://github.com/github/gitignore/blob/main/C++.gitignore

*.obj
*.exe
*.out

# ==================== Python ====================

# https://github.com/github/gitignore/blob/main/Python.gitignore

*.pyc
__pycache__/
*.pyo

```

## Verifying Pattern Effectiveness

After adding patterns, verify they match your compiled files using Git's check-ignore command:

```bash
git check-ignore -v path/to/your/file.class

```

This command outputs the specific `.gitignore` line number and pattern that causes the file to be ignored, confirming your configuration correctly targets the compiled output files.

## Summary

- **Use language-specific templates** from `github/gitignore` rather than maintaining custom patterns, as they are community-verified against current compiler versions.
- **Reference exact file paths** like `Java.gitignore` (line 2) for `.class`, `C.gitignore` (line 32) for `.o`, and `Python.gitignore` (line 4) for `.pyc` to ensure authoritative patterns.
- **Combine templates** by concatenating relevant sections when working with multiple languages in a single repository.
- **Verify ignores** using `git check-ignore` before committing to confirm compiled outputs are properly excluded.

## Frequently Asked Questions

### Can I combine multiple gitignore templates in one project?

Yes. Polyglot repositories commonly concatenate sections from multiple templates. Place language-specific sections in your `.gitignore` with clear comments indicating their source, such as copying the `*.class` pattern from `Java.gitignore` alongside `*.pyc` from `Python.gitignore`. Git applies all patterns cumulatively.

### Should I copy the entire template or just specific lines?

Copy specific lines for minimal, targeted ignores when you only need to exclude compiled outputs. Copy the entire template when you want comprehensive coverage of all build artefacts, including package manager directories and IDE configuration files that the full templates provide.

### How are these templates kept current with new compiler versions?

The `github/gitignore` repository is maintained by thousands of community contributors who update templates as new build tools emerge. Patterns for established formats like `.class` and `.o` remain stable, while emerging toolchains receive updates through pull requests reviewed by language experts.

### Do these patterns work for compiled files in subdirectories?

Yes. Gitignore patterns without leading slashes apply recursively to all subdirectories. The patterns `*.class`, `*.o`, and `*.pyc` from the official templates will match compiled output files regardless of their depth in the repository tree, ensuring nested build directories remain clean.