What Symbol For Greater Than

Understanding the Greater Than Symbol

The character > is one of those things you use without thinking about. It appears in code every day, in math documents, and even in casual web URLs. But like a lot of basic symbols, it causes more headaches than people expect once you actually need to deal with it properly.

What Symbol For Greater Than

The greater than symbol is a simple right-pointing angle bracket. In Unicode it sits at U+003E, and in HTML entities it's either > or >. That second form is the one that trips people up most often. I spent a whole afternoon debugging a Python script last year where a config file was using the literal > character in a JSON string, and the parser kept rejecting it. The file technically passed YAML validation but broke when the data hit the JSON decoder three layers deep. The fix was just wrapping it in double quotes, but I ended up writing a small conversion script anyway because it happened across twelve different config files in the repo.

The ASCII code point is decimal 62, hexadecimal 3E. In HTML you need to escape it as > because raw angle brackets have structural meaning in markup. Leave it unescaped inside an element's content and the browser treats it as the start of a tag. This is why you see it so often in HTML source code -- not because the designers wanted obfuscation, but because the parser can't distinguish between your text and actual markup without the escape. In SQL you'll see it everywhere in WHERE clauses. The syntax is straightforward: SELECT * FROM users WHERE age > 18. But here's the thing nobody mentions -- in some dialects, particularly older versions of Oracle, using > inside a string literal without proper escaping can cause unexpected truncation. I learned this the hard way when a report query returned half the rows it should have, and the > character in a LIKE pattern was getting swallowed by the parser. Python handles it cleanly. No surprises there. But if you're working with string formatting that involves angle brackets -- f-strings, format(), or template engines -- you need to be careful. Double them up or wrap them in braces, or the formatter will choke on what it thinks is a format specifier.

In markup languages like HTML and XML, > terminates tags. This means inside a tag's attribute value you can sometimes use it unescaped, but inside text content you absolutely cannot. Browsers are forgiving, which is another problem. A raw > in content gets rendered correctly most of the time, but not always. Firefox handles it fine, Chrome too, but Safari on older versions would sometimes break the layout entirely.

Edge Cases That Will Bite You

The > character interacts badly with a few specific formats. Regular expressions are one. In most regex flavors, > has no special meaning on its own, but if you're using extended patterns or lookarounds it can conflict.

I ran into a issue with a Perl script that was parsing log files. The regex used > to mean "greater than" in a mathematical context within the pattern, but the input data also contained > as a literal separator in some fields. The match succeeded but captured the wrong groups because the regex engine prioritized the > operator over the literal match. Switching to a character class [>] for the literal and keeping the bare > for the operator fixed it in about five minutes. Shell scripting is another trap zone. In bash, > redirects output to a file. If you put a space before it, it still redirects. The only time it doesn't is when it's inside single quotes or properly escaped. I've seen senior engineers spend thirty minutes debugging a build script because an environment variable containing > got expanded inside a double-quoted string. URL encoding represents it as %3E. This comes up constantly in web development when building query strings or path segments dynamically. Most modern frameworks handle this automatically, but if you're constructing URLs by hand -- which happens more than you'd think in legacy systems -- forgetting to encode > gives you invalid URLs that look correct until they don't.

Common Pitfalls

Using > in regex alternation groups without anchoring can silently match wrong positions. Using it in CSV exports with unquoted fields breaks parsing when the field itself contains the character. And embedding it in email templates without HTML entity escaping renders broken in Gmail's preview mode.

The CSV problem is especially nasty because the data looks valid in Excel. Excel won't complain about unescaped > in a field unless you explicitly set the field to text format first. Your downstream processing pipeline might be reading the file and splitting on > as a delimiter, expecting numeric comparison, and silently producing garbage output instead of raising an error.

Alternatives When > Doesn't Work

If you need to represent "greater than" in contexts where the > character causes problems, consider using the word "exceeds" or "above" in documentation. In code, >= covers the common comparison case and avoids ambiguity in edge-case parsers. For HTML, always use the entity > in text content -- it's explicit, works everywhere, and saves you from browsers that make inconsistent decisions about unescaped markup.

Some systems offer unicode alternatives like the mathematical double-struck greater-than sign ( at U+29C6), but these have zero practical advantage. They're less readable, break in most fonts, and don't solve the core problem. Stick with the standard ASCII > and escape it properly where needed.