What Does ?[31m Mean? Complete Guide to ANSI Color Codes in Terminals

If you have ever run a Python, C, C++, Node.js, Linux, or other command-line program, you may have seen strange text such as ?[31m in the terminal.

At first, it may look like an error or an unknown command. However, ?[31m is usually related to ANSI escape codes, which are used by terminals to control text colors, styles, and formatting.

In this guide, we will explain exactly what ?[31m means, why it appears, where it comes from, and how you can fix it when it is displayed incorrectly.

What Does ?[31m Mean?

The code 31m is an ANSI escape sequence used to set the text color to red in a terminal.

In a properly configured terminal, the actual ANSI sequence is:

ESC[31m

Here:

• ESC is the Escape character.
• [ starts the ANSI control sequence.
• 31 represents the red foreground color.
• m tells the terminal to apply the color formatting.

So, when a program outputs an ANSI sequence such as ESC[31m, the terminal normally displays the following text in red instead of showing the code itself.

Why Do I See ?[31m Instead?

If your terminal or application does not correctly interpret ANSI escape sequences, the escape character may be displayed as ? or another visible character.

Instead of seeing colored text, you may therefore see something like:

?[31mError

The program may not actually be broken. The problem can simply be that the environment displaying the output does not understand or process ANSI color codes correctly.

What Are ANSI Escape Codes?

ANSI escape codes are special character sequences used to control terminal output.

They can be used to:

• Change text color
• Change background color
• Make text bold
• Underline text
• Clear parts of the terminal
• Move the cursor
• Control terminal formatting

They are widely used in command-line applications, programming languages, scripts, and development tools.

For example:

ESC[31m

sets the foreground text color to red.

To reset the formatting back to normal, applications commonly use:

ESC[0m

Common ANSI Color Codes

Here are some commonly used ANSI foreground color codes:

Code	Color
30	Black
31	Red
32	Green
33	Yellow
34	Blue
35	Magenta
36	Cyan
37	White
0	Reset formatting

For example:

ESC[31m

means red text.

And:

ESC[32m

means green text.

While:

ESC[0m

resets the terminal formatting.

Example of ANSI Color Codes

Suppose a Python application wants to print an error message in red.

It may use an ANSI escape sequence similar to:

print("\033[31mError!\033[0m")

A compatible terminal will display:

Error!

in red.

The \033 represents the Escape character.

If the terminal does not support ANSI formatting correctly, you may see the escape sequence instead of the colored output.

Why Is ?[31m Showing in My Terminal?

There are several possible reasons why you may see ?[31m.

1. Your Terminal Does Not Support ANSI Formatting

Some older terminals or terminal-like environments may not properly interpret ANSI escape sequences.

As a result, the control characters are displayed as ordinary text.

2. Output Is Being Redirected

ANSI color codes are designed primarily for terminal output.

If a program sends colored output to a file, log system, or another application, the ANSI sequences may appear as plain text.

For example:

?[31mError?[0m

may appear inside a log file.

3. The Application Is Using Colorized Output

Many modern libraries automatically add colors to terminal output.

Examples include:

• Python CLI applications
• Node.js tools
• npm packages
• Linux commands
• Git tools
• C and C++ applications
• Build systems
• Development frameworks

If the output is being viewed somewhere that does not support ANSI codes, those sequences can become visible.

4. Terminal Compatibility Problems

Different operating systems and terminal environments can handle ANSI sequences differently.

For example, an application may work correctly in one terminal but display formatting codes incorrectly in another environment.

How to Fix ?[31m

If you are seeing ?[31m in your output and want normal readable text, try the following solutions.

Use a Modern Terminal

Try running the program in a modern terminal such as:

• Windows Terminal
• PowerShell
• Command Prompt with appropriate ANSI support
• Linux Terminal
• macOS Terminal

Modern terminals generally provide much better support for ANSI escape sequences.

Disable Colored Output

Many command-line applications provide an option to disable colors.

Depending on the application, you may find options such as:

--no-color

or:

--color=false

The exact option depends on the software you are using.

Check Your Python Program

If you are developing a Python application, you may be explicitly printing ANSI codes.

For example:

print("\033[31mHello\033[0m")

If you do not want colored output, simply remove the ANSI formatting:

print("Hello")

Use an ANSI-Compatible Library

For larger applications, using a library designed to handle terminal colors can make your code easier to manage.

For example, Python developers commonly use terminal-color libraries to handle colors automatically and consistently.

Is ?[31m an Error?

No, ?[31m itself is generally not an error.

It is usually a visible representation of an ANSI escape sequence that was supposed to control terminal formatting.

For example:

?[31mWarning

may actually have been intended to mean:

Warning

with the word displayed in red.

However, if ?[31m appears alongside an actual error message, the underlying error should still be investigated separately.

Difference Between ?[31m and ESC[31m

There is an important difference.

The proper ANSI sequence contains an actual Escape character:

ESC[31m

When the Escape character is not interpreted correctly, it may appear as:

?[31m

Therefore, ?[31m is usually not the original code itself. It is often how the unsupported or incorrectly displayed escape character appears in a particular environment.

What Does ESC[0m Mean?

You may also see:

ESC[0m

This is another common ANSI escape sequence.

It resets text formatting.

For example:

print("\033[31mRed Text\033[0m Normal Text")

The first sequence makes the text red, while \033[0m resets the formatting.

Without the reset code, subsequent terminal text could remain formatted depending on the terminal and application.

ANSI Codes in Python

Python developers often use ANSI escape sequences to add color to command-line applications.

Example:

RED = "\033[31m"
RESET = "\033[0m"

print(RED + "This is red text" + RESET)

Here:

• RED applies the red color.
• RESET returns the terminal to its default formatting.

This technique is useful for command-line interfaces, debugging tools, scripts, and development utilities.

ANSI Codes in Other Programming Languages

ANSI escape sequences are not limited to Python.

They can also be used in:

• C
• C++
• Java
• JavaScript
• Node.js
• PHP
• Ruby
• Bash
• PowerShell

For example, a C program can output an ANSI sequence to display colored terminal text.

This makes ANSI formatting a common feature across many command-line development environments.

Should You Remove ?[31m?

It depends on where it appears.

If your terminal correctly displays colors and you see red text instead of ?[31m, there is nothing to fix.

If you literally see:

?[31m

in your terminal, log file, website, or application output, you may want to:

1. Check whether ANSI processing is supported.
2. Use a compatible terminal.
3. Disable color output.
4. Strip ANSI escape sequences from logs.
5. Check the application or library generating the output.

How to Remove ANSI Escape Codes From Text

If ANSI codes are being saved inside a log file or text output, they can be removed before displaying the text.

A simple example in Python is:

import re

text = "\033[31mError\033[0m"

clean_text = re.sub(r'\x1b\[[0-9;]*m', '', text)

print(clean_text)

The output becomes:

Error

This can be useful when processing terminal output before storing it in databases, displaying it on websites, or creating clean log files.

Frequently Asked Questions

What is ?[31m?

?[31m is usually a visible representation of an ANSI escape sequence. The 31 code represents the red foreground color.

Is ?[31m dangerous?

No. By itself, ?[31m is normally just a terminal formatting code and is not a virus or malware.

What does 31m mean?

In ANSI terminal formatting, 31 sets the foreground text color to red, while m indicates that the formatting command should be applied.

Why am I seeing ANSI codes instead of colors?

Your terminal, application, log viewer, or output environment may not be interpreting ANSI escape sequences.

How do I stop ?[31m from appearing?

You can use an ANSI-compatible terminal, enable ANSI processing where supported, or disable colored output in the application generating the text.

Does ?[31m mean there is a programming error?

Not necessarily. It usually indicates a formatting sequence being displayed incorrectly. The actual program error, if any, is usually separate.

What does ESC[0m mean?

ESC[0m resets ANSI text formatting to the terminal’s default style.

Final Thoughts

The strange-looking ?[31m sequence is usually nothing to worry about. It is commonly associated with ANSI escape codes, which command-line applications use to add colors and formatting to terminal output.

The important part is 31, which represents the color red. When ANSI formatting is supported, the terminal interprets the sequence and displays the following text in red. When it is not supported, the escape sequence may appear as visible characters such as ?[31m.

Understanding ANSI escape codes can be especially useful for developers working with Python, C, C++, JavaScript, Node.js, Linux, Windows terminals, command-line tools, and debugging output.

If you see ?[31m in your terminal, it usually means that a color-formatting instruction is being displayed instead of being interpreted.