How to change line-ending settings

Is there a file or menu that will let me change the settings on how to deal with line endings?

I read there are 3 options:

Checkout Windows-style, commit Unix-style

Git will convert LF to CRLF when checking out text files. When committing text files, CRLF will be converted to LF. For cross-platform projects, this is the recommended setting on Windows («core.autocrlf» is set to «true»)

Checkout as-is, commit Unix-style

Git will not perform any conversion when checking out text files. When committing text files, CRLF will be converted to LF. For cross-platform projects this is the recommended setting on Unix («core.autocrlf» is set to «input»).

Checkout as-is, commit as-is

Git will not perform any conversions when checking out or committing text files. Choosing this option is not recommended for cross-platform projects («core.autocrlf» is set to «false»)

5 Answers 5

The normal way to control this is with git config

For details, scroll down in this link to Pro Git to the section named «core.autocrlf»

If you want to know what file this is saved in, you can run the command:

and the git global config file should open in a text editor, and you can see where that file was loaded from.

Line ending format used in OS

• Windows: CR (Carriage Return \r ) and LF (LineFeed \n ) pair
• OSX,Linux: LF (LineFeed \n )

We can configure git to auto-correct line ending formats for each OS in two ways.

1. Git Global configuration
2. Use .gitattributes file

Global Configuration

This will fix any CRLF to LF when you commit.

This will make sure when you checkout in windows, all LF will convert to CRLF

.gitattributes File

It is a good idea to keep a .gitattributes file as we don’t want to expect everyone in our team set their config. This file should keep in repo’s root path and if exist one, git will respect it.

This will treat all files as text files and convert to OS’s line ending on checkout and back to LF on commit automatically. If wanted to tell explicitly, then use

First one is for checkout and second one is for commit.

Treat all .jpg images as binary files, regardless of path. So no conversion needed.

Or you can add path qualifiers:

For a repository setting solution, that can be redistributed to all developers, check out the text attribute in the .gitattributes file. This way, developers dont have to manually set their own line endings on the repository, and because different repositories can have different line ending styles, global core.autocrlf is not the best, at least in my opinion.

For example unsetting this attribute on a given path [. — text] will force git not to touch line endings when checking in and checking out. In my opinion, this is the best behavior, as most modern text editors can handle both type of line endings. Also, if you as a developer still want to do line ending conversion when checking in, you can still set the path to match certain files or set the eol attribute (in .gitattributes) on your repository.

Also check out this related post, which describes .gitattributes file and text attribute in more detail: What’s the best CRLF (carriage return, line feed) handling strategy with Git?

For me what did the trick was running the command

inside the folder of the project, I wanted it specifically for one project.

That command changed the file in path /.git/config (fyi .git is a hidden folder) by adding the lines

at the end of the file. I suppose changing the file does the same trick as well.

Git status ignore line endings / identical files / windows & linux environment / dropbox / mled

ignore line ending differences?

I use randomly Windows and Linux to work on the project. The project is in Dropbox.

I found a lot about how do make git diff ignore line endings. Since i use meld git diff opens meld for each file. And meld says «identical file».

So how do I avoid this. Git should only open meld for changed files. And git status should not report files as changed if only the file ending is different.

EDIT: Cause:

This happened because of this setting on Windows

So I checked out the working copy on Linux and set core.autocrlf false on Windows.

It would be still nice to know how to make git status ignore different new lines.

6 Answers 6

Try setting core.autocrlf value like this :

This answer seems relevant since the OP makes reference to a need for a multi-OS solution. This Github help article details available approaches for handling lines endings cross-OS. There are global and per-repo approaches to managing cross-os line endings.

Global approach

Configure Git line endings handling on Linux or OS X:

Configure Git line endings handling on Windows:

Per-repo approach:

In the root of your repo, create a .gitattributes file and define line ending settings for your project files, one line at a time in the following format: path_regex line-ending-settings where line-ending-settings is one of the following:

• text
• binary (files that Git should not modify line endings for — as this can cause some image types such as PNGs not to render in a browser)

The text value can be configured further to instruct Git on how to handle line endings for matching files:

• text — Changes line endings to OS native line endings.
• text eol=crlf — Converts line endings to CRLF on checkout.
• text eol=lf — Converts line endings to LF on checkout.
• text=auto — Sensible default that leaves line handle up to Git’s discretion.

Here is the content of a sample .gitattributes file:

More on how to refresh your repo after changing line endings settings here. Tldr:

backup your files with Git, delete every file in your repository (except the .git directory), and then restore the files all at once. Save your current files in Git, so that none of your work is lost.

git commit -m «Saving files before refreshing line endings»

Remove the index and force Git to rescan the working directory.

Rewrite the Git index to pick up all the new line endings.

Show the rewritten, normalized files.

In some cases, this is all that needs to be done. Others may need to complete the following additional steps:

Add all your changed files back, and prepare them for a commit. This is your chance to inspect which files, if any, were unchanged.

It is perfectly safe to see a lot of messages here that read[s] «warning: CRLF will be replaced by LF in file.»

Commit the changes to your repository.

git commit -m «Normalize all the line endings»

Normalizing line endings in Visual Studio 2010

We have multiple developers working on an application and it seems that whenever one particular person works on a file then anyone else works on it they will get:

The line endings in the following file are not consistent. Do you want to normalize the line endings?

Is there some option in Visual Studio that we can have that developer change so we don’t continually have this very irritating message pop up all the time?

4 Answers 4

If you don’t want Visual Studio to check this when it opens the file, you can uncheck the box when prompted («Always show this dialog») or in Tools->Options under Environment->Documents-> «Check for consistent line endings on load»

Someone on your project is probably using an editor that uses Unix-style or Mac-style line endings.

It appears that Visual Studio preserve line endings when you copy/paste code from other sources. It means that even if you work alone on one platform you can get those annoying warnings.

We recently had mixed Mac and Windows line endings in a script after some code copy/paste from other project.

The issue was solved through copying the whole mixed code into a proper text-editor which was Notepad++. We then copied the text from Notepad++ and replaced text in Visual Studio. The resulting text had unified line endings.

jonlabelle / crlf.py

#!/usr/bin/env python

«»»Replace line breaks, from one format to another.»»»

from __future__ import print_function

import argparse

import glob

import os

import sys

import tempfile

from stat import ST_ATIME , ST_MTIME

LF = ‘ \n ‘

CRLF = ‘ \r \n ‘

CR = ‘ \r ‘

def _normalize_line_endings ( lines , line_ending = ‘unix’ ):

r»»»Normalize line endings to unix (\n), windows (\r\n) or mac (\r).

:param lines: The lines to normalize.

:param line_ending: The line ending format.

Acceptable values are ‘unix’ (default), ‘windows’ and ‘mac’.

:return: Line endings normalized.

«»»

lines = lines . replace ( CRLF , LF ). replace ( CR , LF )

if line_ending == ‘windows’ :

lines = lines . replace ( LF , CRLF )

elif line_ending == ‘mac’ :

lines = lines . replace ( LF , CR )

return lines

def _copy_file_time ( source , destination ):

«»»Copy one file’s atime and mtime to another.

:param source: Source file.

:param destination: Destination file.

«»»

file1 , file2 = source , destination

try :

stat1 = os . stat ( file1 )

except os . error :

sys . stderr . write ( file1 + ‘ : cannot stat \n ‘ )

sys . exit ( 1 )

try :

os . utime ( file2 , ( stat1 [ ST_ATIME ], stat1 [ ST_MTIME ]))

except os . error :

sys . stderr . write ( file2 + ‘ : cannot change time \n ‘ )

sys . exit ( 2 )

def _create_temp_file ( contents ):

«»»Create a temp file.

:param contents: The temp file contents.

:return: The absolute path of the created temp file.

«»»

tf = tempfile . NamedTemporaryFile ( mode = ‘wb’ , suffix = ‘txt’ , delete = False )

tf . write ( contents )

tf . close ()

return tf . name

def _delete_file_if_exists ( filepath ):

«»»Delete the file if it exists.

:param filepath: The file path.

«»»

if os . path . exists ( filepath ):

os . remove ( filepath )

def _read_file_data ( filepath ):

«»»Read file data.

:param filepath: The file path.

:return: The file contents.

«»»

data = open ( filepath , ‘rb’ ). read ()

return data

def _write_file_data ( filepath , data ):

«»»Write file data.

:param filepath: The file path.

:param data: The data to write.

«»»

f = open ( filepath , ‘wb’ )

f . write ( data )

f . close ()

def main ():

«»»Main.»»»

parser = argparse . ArgumentParser (

prog = ‘crlf’ ,

description = ‘Replace CRLF (windows) line endings with LF (unix) ‘

‘line endings in files, and vice-versa’ )

parser . add_argument (

‘-q’ , ‘—quiet’ ,

help = ‘suppress descriptive messages from output’ ,

action = ‘store_true’ ,

default = False )

parser . add_argument (

‘-n’ , ‘—dryrun’ ,

help = ‘show changes, but do not modify files’ ,

action = ‘store_true’ ,

default = False )

parser . add_argument (

‘-w’ , ‘—windows’ ,

help = ‘replace LF (unix) line endings with CRLF (windows) line endings’ ,

action = ‘store_true’ ,

default = False )

parser . add_argument (

‘-u’ , ‘—unix’ ,

help = ‘replace CRLF (windows) line endings with LF (unix) ‘

‘line endings (default)’ ,

action = ‘store_true’ ,

default = False )

parser . add_argument (

‘-t’ , ‘—timestamps’ ,

help = «maintains the modified file’s time stamps (atime and mtime)» ,

action = ‘store_true’ ,

default = False )

parser . add_argument (

‘files’ ,

nargs = ‘+’ ,

help = «a list of files or file glob patterns to process» ,

default = ‘.’ )

if len ( sys . argv ) 2 :

parser . print_help ()

sys . exit ( 2 )

args = parser . parse_args ()

if args . windows is True and args . unix is True :

sys . stderr . write ( «Ambiguous options specified, ‘unix’ and ‘windows’. «

«Please choose one option, or the other. \n » )

sys . exit ( 2 )

files_to_process = []

for arg_file in args . files :

files_to_process . extend ( glob . glob ( arg_file ))

if len ( files_to_process ) 0 :

if args . quiet is False :

sys . stderr . write ( ‘No files matched the specified pattern. \n ‘ )

sys . exit ( 2 )

if args . dryrun is True and args . quiet is False :

print ( ‘Dry-run only, files will NOT be modified.’ )

for file_to_process in files_to_process :

if os . path . isdir ( file_to_process ):

if args . quiet is False :

print ( «- ‘<0>‘ : is a directory (skip)» . format ( file_to_process ))

continue

if os . path . isfile ( file_to_process ):

data = _read_file_data ( file_to_process )

if ‘ \\ 0’ in data :

if args . quiet is False :

print ( «- ‘<0>‘ : is a binary file (skip)» . format ( file_to_process ))

continue

if args . windows is True :

new_data = _normalize_line_endings ( data , line_ending = ‘windows’ )

else :

new_data = _normalize_line_endings ( data , line_ending = ‘unix’ )

if new_data != data :

if args . quiet is False :

if args . windows is True :

if args . dryrun is True :

print ( «+ ‘<0>‘ : LF would be replaced with CRLF» . format ( file_to_process ))

else :

print ( «+ ‘<0>‘ : replacing LF with CRLF» . format ( file_to_process ))

else :

if args . dryrun is True :

print ( «+ ‘<0>‘ : CRLF would be replaced with LF» . format ( file_to_process ))

else :

print ( «+ ‘<0>‘ : replacing CRLF with LF» . format ( file_to_process ))

tmp_file_path = «»

if args . dryrun is False :

try :

if args . timestamps is True :

# create a temp file with the original file

# contents and copy the old file’s atime a mtime

tmp_file_path = _create_temp_file ( data )

_copy_file_time ( file_to_process , tmp_file_path )

# overwrite the current file with the modified contents

_write_file_data ( file_to_process , new_data )

if args . timestamps is True :

# copy the original file’s atime and mtime back to

# the original file w/ the modified contents,

# and delete the temp file.

_copy_file_time ( tmp_file_path , file_to_process )

_delete_file_if_exists ( tmp_file_path )

except Exception as ex :

sys . stderr . write ( ‘error : <0>\n ‘ . format ( str ( ex )))

sys . exit ( 1 )

else :

if args . quiet is False :

if args . windows is True :

print ( «- ‘<0>‘ : line endings already CRLF (windows)» . format ( file_to_process ))

else :

print ( «- ‘<0>‘ : line endings already LF (unix)» . format ( file_to_process ))

else :

sys . stderr . write ( «- ‘<0>‘ : file not found \n » . format ( file_to_process ))

sys . exit ( 1 )

if __name__ == ‘__main__’ :

main ()

You can’t perform that action at this time.

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.