The use of sigils was popularized by the BASIC programming language. The best known example of a sigil in BASIC is the dollar sign (“
$”) appended to the names of all strings. Many BASIC dialects use other sigils to denote integers and floating point numbers, and sometimes other types as well.
Larry Wall adopted shell scripting’s use of sigils for his scripting language Perl. However, as Perl is a dynamically typed language, the sigils specify not fine-grained data types like strings and integers, but general categories such as scalars (using a prefixed “
$”), arrays (using a “
@”), hashes (using a “
%”), and subroutines (using a “
&”). Perl 6 introduces secondary sigils, or twigils, which are used to indicate the scope of variables. Prominent examples of twigils in Perl 6 include “
^”, used with self-declared formal parameters (“placeholder variables”), and “
.”, used with object attribute accessors (i.e., instance variables).
In Unix shell scripting and other utilities such as Makefiles, the "
$" is a unary operator that translates the name of a variable into its contents. Many people confuse this with a sigil, but it is properly a unary operator for lexical indirection, similar to the
* indirection operator for pointers in C.
In the MUMPS programming language, global variables and routines (procedures or subroutines) are prefixed by an uparrow (^), and the last identifier used can be referenced indirectly by an uparrow alone, this is referred to as the "naked" identifier.
In Ruby, ordinary variables lack sigils, but “
$” is prefixed to global variables, “
@” is prefixed to instance variables, and “
@@” is prefixed to class variables (the second “
@” cannot be considered a twigil, so “
@@” is just a longer sigil).
In Transact-SQL, “
@” precedes a local variable or parameter name. System variables (known as global variables) are distinguished by a “
In mIRC script, identifiers have a $ sigil, while all variables have a % prefixed (regardless of local or global variables or data type). Binary variables are prefixed by a &.
In XSLT, variables and parameters have a leading $ sigil on use, although when defined in
with the “
name” attribute, the sigil is not included. Related to XSLT, XQuery uses the $ sigil form both in definition and in use.
In CLIPS, scalar variables are prefixed with a ? sigil while multifield (i.e. a 1-level list) variables are prefixed with $?.
In C#, any variable names may be prefixed with
@. This is mainly used to allow the use of variable names that would otherwise conflict with keywords.
@ sigil can also be applied to string literals, which changes the way they are interpreted (character escapes are not used and strings can extend over multiple lines).
Related to sigils is Hungarian notation, a convention for variable-naming that specifies variable type by attaching certain alphabetic prefixes to the variable name. Unlike sigils, however, Hungarian notation provides no information to the compiler; as such, explicit types must be redundantly given for the variables and the prefixes are not enforced, making them more prone to omission and misuse.