At Sign @: Email, Usernames, Mentions, and Programming Uses

The at sign @ can do very different jobs without changing shape. It separates the two main parts of an email address, prefixes many handles and mentions, begins CSS at-rules, and appears in Python syntax.

Unicode encodes the ordinary at sign as U+0040 COMMERCIAL AT. Like many keyboard characters, its code point identifies the character but not the job it is doing in a particular piece of text.

Email Gives @ a Precise Structural Job

In the standard form of an Internet email address, the at sign separates the local part from the domain:

local-part@domain

For example:

name@example.com

RFC 5322 describes the local part as a domain-dependent string followed by the @ character and then an Internet domain. The interpretation of the local part therefore belongs to the receiving domain; it is safer to call it the local part than to assume it is literally a person’s mailbox name.

The separator is part of the address syntax. A visually similar character is not automatically interchangeable with U+0040, and ordinary spaces are not simply decorative around it.

@name Is a Platform Convention, Not a Universal Address Format

Many social, collaboration, and developer platforms use forms such as @alex for a handle or mention. The convention is familiar, but each service defines its own rules for usernames, display names, allowed characters, and notification behavior.

@name is therefore a platform convention rather than an email-address form. The service decides whether it represents a handle, mention, notification target, or something else.

Even within social and collaboration apps, typing @name does not guarantee identical behavior. One service may create a clickable mention, another may leave plain text, and permissions or autocomplete rules can affect whether anyone is actually notified.

Why Unicode Calls It COMMERCIAL AT

Unicode’s formal name is COMMERCIAL AT, not “email sign.” The character existed before modern email, and its encoded name preserves that older commercial association.

The Unicode Standard also notes that email made @ so prominent that language communities developed many informal names for it. That history explains the gap between the formal character name and the modern use most people recognize first.

CSS At-Rules Literally Start with @

CSS uses an at sign followed by a name to begin an at-rule. Familiar examples include:

@import "theme.css";

@media print {
  body { font-size: 10pt; }
}

Here @ is part of CSS syntax. It is not an email separator or a social-media mention.

CSS at-rules vary in what follows their name: some end as statements, while others introduce blocks. What they share is the initial U+0040 code point.

Python Uses @ in Two Unrelated-Looking Places

Python makes the contextual nature of @ especially obvious. At the start of decorator syntax, it appears before a decorator name:

@staticmethod
def build():
    pass

Between expressions, the same character is the matrix-multiplication operator:

result = left @ right

Python also defines @= as the corresponding augmented-assignment form. An @ above a function definition and an @ between two operands are therefore the same Unicode character participating in different grammar.

Ordinary @ and Fullwidth ＠ Are Different Code Points

Unicode also contains ＠, U+FF20 FULLWIDTH COMMERCIAL AT. It has a compatibility mapping to ordinary U+0040 @, but the raw text still contains a different code point before compatibility normalization.

Exact-syntax contexts expose the difference quickly. A fullwidth lookalike pasted into an email address, username field, or source file should not be assumed to behave like the ASCII at sign unless the receiving system explicitly normalizes or accepts it.

That is different from a font merely drawing U+0040 in an unusual way. A font changes the glyph; U+FF20 changes the character stored in the text.

@ Can Also Be Ordinary Data Inside Code

Seeing an at sign in a source file does not automatically make it an operator or language marker. Inside a string such as "name@example.com", the character is data contained by the string literal. Python does not interpret that @ as matrix multiplication, and CSS does not turn an at sign inside a quoted URL or string into an at-rule.

Source code adds another layer: the same character can be active syntax in one position and ordinary data in another. Parsers first consider where it occurs—inside a string, inside a comment, or in active language grammar.

U+0040 tells you which character is present, but not what that character is doing in the surrounding syntax or data.

Read the Neighbors Around @

Read the immediate surroundings. Between a local part and domain, @ belongs to an email address; before a CSS rule name or Python decorator, it is active syntax; inside a quoted string, it may be ordinary data. In all of those cases the stored character can still be U+0040.