How to print 'µ' in the serial monitor?
Most of what follows has already been covered in previous answers. I am
posting this nevertheless because I feel no answer so far makes the
whole story clear enough. Let me break down the question into two
sub-questions.

1. How can I get non-ASCII characters correctly print on the serial monitor?

The answer is simply send them as UTF-8.

That's really all there is to it. The serial monitor expects you to send
UTF-8, and it will print the characters correctly only if you use this
encoding. But that brings the second question:

2. How can I get the characters as UTF-8 in my Arduino program?

Here you have several options:

Option 1: encode them yourself

For example, the Greek letter “μ” (U+03BC) in UTF-8 is (0xce 0xbc). You
can send those bytes explicitly, like

Serial.write(0xce);
Serial.write(0xbc);


or, more comfortably, like

Serial.print("\xce\xbc");


The second syntax is more convenient because it allows the character to
be embedded within a longer string.

Option 2: let the Arduino IDE encode them

If you can get the characters in the IDE's editor window, either with an
appropriate keyboard layout or by copying and pasting from another
application, then you can use them as is in the string:

Serial.print("μ");


The editor will save the source code as UTF-8, and those UTF-8 bytes
will go undisturbed from the source file to the compiled program, to the
Arduino memory, to the serial port, and finally to the serial monitor.

This option is the best for readability. However, it is somewhat
fragile: if the source code ever gets re-encoded (e-mail clients and
servers sometimes do that), then the resulting program will not work as
expected.

Options 3: let the compiler encode them

You can ask the compiler to do the UTF-8 encoding for you with the
syntax

Serial.print(u8"\u03bc");


Here, the escape sequence \u03bc is a way to represent the Unicode
character U+03BC (i.e. “μ”), and the u8 prefix means that you want the
string as a byte array encoded in UTF-8.

Note that, in practice, the u8 prefix is not needed, as the gcc
compiler assumes UTF-8 by default. I would keep the prefix anyway
because it doesn't hurt to make the encoding explicit, and it may avoid
angering some language lawyer...

Note also that the syntax above only works for characters U+0000 through
U+FFFF, i.e. the basic multilingual plane. For other Unicode characters,
you have to use the syntax \U + 8 hex digits. For example, the
character “” (U+1F60E: smiling face with sunglasses) can be printed
with:

Serial.print(u8"\U0001f60e");


Clarification about UTF-16: A common misconception has it that with
\u you write the characters as UTF-16 code units, and with \U you
write UTF-32 code units. But it is incorrect:
both syntaxes are used to describe a
single character (technically, a code point), irrespective of the
encoding. Since the UTF-16 encoding for “” is (0xd83d 0xde0e), one
could be tempted to write

// Write as UTF-16 code units in the source code.
Serial.print("\ud83d\ude0e");  // WRONG


but then the compiler rightfully complains

error: \ud83d is not a valid universal character
error: \ude0e is not a valid universal character


So forget about UTF-16. There is no UTF-16 involved anywhere, except in
the internal representation used by a Java widget used to implement the
serial monitor, which is a completely irrelevant implementation detail.