Encountering mysterious ^M characters in your files when working with Emacs can be a puzzling experience, especially if you’re new to the world of command-line text editors or cross-platform development. These seemingly random symbols often appear out of nowhere, cluttering your code or plain text documents and causing confusion. Rest assured, you’re not alone in wondering what these ^M characters are or why they keep showing up in your files. This comprehensive guide will demystify these enigmatic characters, explain their origins, and provide practical, actionable strategies for both removing them and preventing their future appearance, ensuring your Emacs experience remains clean and productive.

Understanding the Elusive ^M Character

The ^M character, often displayed as ^M, <cr></cr>, or \r, is a visual representation of the carriage return control character. Historically, typewriters used a carriage return to move the print head to the beginning of the line, and a line feed (^J or \n) to advance the paper to the next line. This two-character sequence, known as Carriage Return Line Feed (CRLF), became the standard line ending convention for many operating systems, most notably Microsoft Windows. In contrast, Unix-like systems (Linux, macOS) adopted only the line feed (LF) character to signify the end of a line.

When you open a file created on a Windows system in a Unix-like environment or an editor configured for Unix line endings, such as Emacs, the separate carriage return characters (^M) become visible. Emacs, by default, is designed to show you all characters, including non-printable ones like control characters, which can be incredibly useful for debugging file encoding issues. This transparency is why you see the ^M characters, whereas other, more “user-friendly” text editors might silently convert or hide them, potentially masking underlying file format discrepancies.

If you’re seeing ^M characters in your Emacs files, it almost invariably means that the file originated from or was last saved on a Windows system using CRLF (Carriage Return Line Feed) line endings, and you are viewing it in an environment or editor, like Emacs, that primarily uses LF (Line Feed) line endings. These characters are not errors but rather the visible representation of the carriage return component of Windows-style line endings.

Why Emacs Shows ^M and Other Editors Don’t

Emacs’s behavior of displaying ^M characters stems from its philosophy as a powerful, extensible text editor designed for developers and power users. Unlike simpler text editors that might automatically strip or hide these characters, Emacs aims to give the user full control and visibility into the raw content of their files. This transparency is often a feature, not a bug, especially when dealing with mixed-environment projects or debugging subtle file corruption issues.

Other editors, particularly those aimed at general users or specific operating systems, often employ automatic line ending conversions or simply suppress the visual display of control characters. For instance, Notepad++ on Windows can be configured to show all characters but typically handles line endings gracefully. Similarly, many IDEs (Integrated Development Environments) automatically detect and adjust to the file’s line ending style, or provide options to convert them on the fly. This can create a false sense of consistency, as the underlying file might still contain the mixed line endings.

Understanding file encodings and line endings is crucial for maintaining code integrity and ensuring cross-platform compatibility, especially in collaborative environments. Emacs’s explicit display of these characters serves as a constant reminder of potential inconsistencies. For more details on character encodings and how they impact your workflow, you might find this resource on understanding text encoding helpful.

Practical Solutions: Removing ^M from Your Files

Once you understand what the ^M characters represent, removing them is straightforward. There are several methods you can employ, both within Emacs and using external command-line tools, depending on your preference and the number of files you need to clean.

Within Emacs:

• Using replace-regexp: This is a common and effective method for single files. You can use Emacs’s powerful regular expression search and replace functionality. Press M-x replace-regexp (or C-M-%). When prompted for the regular expression, type C-q C-m (which inserts the actual carriage return character, often displayed as ^M in the minibuffer). When prompted for the replacement, just press Enter to replace it with nothing. This effectively deletes all carriage returns.
• Setting the Buffer’s Coding System: For a more permanent solution for the current file, or when saving, you can change the file’s coding system. Use M-x set-buffer-file-coding-system and select a Unix-style encoding like utf-8-unix or latin-1-unix. When you save the file, Emacs will write it with LF line endings, effectively stripping the ^M characters.
• C-x RET f (set-visited-file-coding-system): This command allows you to specify the coding system for the current file when you visit it. If you open a file and realize it has ^Ms, you can use this before saving.

Using External Tools:

For batch processing or when you prefer command-line utilities, these tools are indispensable:

• dos2unix: This utility is specifically designed to convert text files from DOS/Windows line endings (CRLF) to Unix line endings (LF). It’s incredibly simple to use: ``` dos2unix your_file.txt

  
  For multiple files, you can use a loop or shell expansion:
  

  find . -type f -name “.txt” -exec dos2unix {} ;

  
  According to a survey by Stack Overflow, a significant portion of developers (over 70%) work on Unix-like systems, making tools like `dos2unix` essential for cross-platform collaboration. (<cite>[Stack Overflow Developer Survey 2023](https://survey.stackoverflow.com/2023/)</cite>)
  

• sed: The stream editor sed is a powerful tool for text transformations. To remove carriage returns, you can use: ``` sed -i ’s/\r//g’ your_file.txt

  
  The `-i` flag edits the file in place. The `s/\r//g` command substitutes all occurrences (`g` for global) of the carriage return character (`\r`) with nothing.
  

• tr: This utility translates or deletes characters. To delete carriage returns: ``` tr -d ‘\r’ < your_file.txt > new_file.txt

  
  This redirects the input from `your_file.txt`, deletes all carriage returns, and outputs to `new_file.txt`. You would then need to replace the original file.
  

Preventing ^M Characters in Emacs (and Beyond)

While removing existing ^M characters is necessary, preventing them from appearing in the first place is the ideal solution. This involves configuring your Emacs environment and adopting best practices in your development workflow.

Configuring Emacs for Line Endings:

You can tell Emacs to save all new files or files of a certain type with specific line Question & Answer :

I think it may have to do with TextMate, but we work in a small team and are having some issues with full-file conflicts of nearly identical files in git – in one branch the files have a ^M appended to each line.

What is this mysterious ^M character supposed to do, and where could it be coming from?

Our developers use emacs on Windows/Mac, TextMate on Mac, coda on Mac, and occasionally the wp-admin text editor.

Did anybody ever have this issue stemming from one of those?

In git-config, set core.autocrlf to true to make git automatically convert line endings correctly for your platform, e.g. run this command for a global setting:

git config --global core.autocrlf true