Incomputer programming, amagic number is anumericliteral insource code that has a special, particular meaning that is less than clear to the reader. Also incomputing, but not limited to programming, the term is used for a number that identifies a particular concept but without additional knowledge its meaning is less than clear. For example, somefile formats are identified by an embedded magic number in thefile(seelist of file signatures). Also, a number that is relatively uniquely associated with a particular concept, such as auniversally unique identifier, might be classified as a magic number.

Amagic number ormagic constant, considered ananti-pattern, is using a numeric literal in source code that has a special meaning that is less than clear. This breaks one of the oldest rules of programming, dating back to theCOBOL,FORTRAN andPL/1 manuals of the 1960s.^[1]

In the following code that computes a price after tax,1.05 is a magic number since the value encodes the sales tax rate, 5%, in a way that is less than obvious.

price_after_tax = 1.05 * price

The use of magic numbers in code obscures the developers' intent in choosing that number,^[2] increases opportunities for subtle errors, and makes it more difficult for the program to be adapted and extended in the future.^[3] As an example, it is difficult to tell whether every digit in3.14159265358979323846 is correctly typed, or if this constant forpi can betruncated to3.14159 without affecting the functionality of the program with its reduced precision. Replacing all significant magic numbers with namedconstants (also called explanatory variables) makes programs easier to read, understand and maintain.^[4]

The example above can be improved by adding a descriptively named variable:

TAX = 0.05price_after_tax = (1.0 + TAX) * price

A good name can result in code that is more easily understood by a maintainer who is not the original author and even the original author after a period of time.^[5] An example of an uninformatively named constant isint SIXTEEN = 16, whileint NUMBER_OF_BITS = 16 might be more useful.

Non-numeric data can have the same magical properties, and therefore, the same issues as magic numbers.^[1] Thus, declaringconst string testUserName = "John" and usingtestUserName might be better than using the literal"John" directly.

For example, if it is required to randomly shuffle the values in an array representing a standard pack ofplaying cards, thispseudocode does the job using theFisher–Yates shuffle algorithm:

for ifrom 1to 52    j := i + randomInt(53 - i) - 1    a.swapEntries(i, j)

wherea is an array object, the functionrandomInt(x) chooses a random integer between 1 andx, inclusive, andswapEntries(i, j) swaps theith andjth entries in the array. In the preceding example,52 and53 are magic numbers, also not clearly related to each other. It is considered better programming style to write the following:

int deckSize:= 52for ifrom 1to deckSize    j := i + randomInt(deckSize + 1 - i) - 1    a.swapEntries(i, j)

This is preferable for several reasons:

• Better readability. A programmer reading the first example might wonder,What does the number 52 mean here? Why 52? The programmer might infer the meaning after reading the code carefully, but it is not obvious.^[5] Magic numbers become particularly confusing when the same number is used for different purposes in one section of code.
• Easier to maintain. It is easier to alter the value of the number, as it is not duplicated. Changing the value of a magic number is error-prone, because the same value is often used several times in different places within a program.^[5] Also, when two semantically distinct variables or numbers have the same value they may be accidentally both edited together.^[5] To modify the first example to shuffle aTarot deck, which has 78 cards, a programmer might naively replace every instance of 52 in the program with 78. This would cause two problems. First, it would miss the value 53 on the second line of the example, which would cause the algorithm to fail in a subtle way. Second, it would likely replace the characters "52" everywhere, regardless of whether they refer to the deck size or to something else entirely, such as the number of weeks in a Gregorian calendar year, or more insidiously, are part of a number like "1523", all of which would introduce bugs. By contrast, changing the value of thedeckSize variable in the second example would be a simple, one-line change.
• Encourages documentation.^[5] The single place where the named variable is declared makes a good place to document what the value means and why it has the value it does. Having the same value in a plethora of places either leads to duplicate comments (and attendant problems when updating some but missing some) or leaves noone place where it's both natural for the author to explain the value and likely the reader shall look for an explanation.
• Coalesces information. The declarations of "magic number" variables can be placed together, usually at the top of a function or file, facilitating their review and change.^[5]
• Detectstypos. Using a variable (instead of a literal) takes advantage of a compiler's checking. Accidentally typing "62" instead of "52" would go undetected, whereas typing "dekSize" instead of "deckSize" would result in the compiler's warning thatdekSize is undeclared.
• Reduces typing. If aIDE supportscode completion, it will fill in most of the variable's name from the first few letters.
• Facilitates parameterization. For example, to generalize the above example into a procedure that shuffles a deck of any number of cards, it would be sufficient to turndeckSize into a parameter of that procedure, whereas the first example would require several changes.

function shuffle (int deckSize)for ifrom 1to deckSize       j := i + randomInt(deckSize + 1 - i) - 1       a.swapEntries(i, j)

Disadvantages are:

• Breaks locality. When the named constant is not defined near its use, it hurts the locality, and thus comprehensibility, of the code. Putting the 52 in a possibly distant place means that, to understand the workings of the "for" loop completely (for example to estimate the run-time of the loop), one must track down the definition and verify that it is the expected number. This is easy to avoid (by relocating the declaration) when the constant is only used in one portion of the code. When the named constant is used in disparate portions, on the other hand, the remote location is a clue to the reader that the same value appears in other places in the code, which may also be worth looking into.
• Causes verbosity. The declaration of the constant adds a line. When the constant's name is longer than the value's, particularly if several such constants appear in one line, it may make it necessary to split one logical statement of the code across several lines. An increase in verbosity may be justified when there is some likelihood of confusion about the constant, or when there is a likelihood the constant may need to be changed, such asreuse of a shuffling routine for other card games. It may equally be justified as an increase in expressiveness.
• Performance considerations. It may be slower to process the expressiondeckSize + 1 at run-time than the value "53". That being said, most modern compilers will use techniques likeconstant folding andloop optimization to resolve the addition during compilation, so there is usually no or negligible speed penalty compared to using magic numbers in code. Especially the cost of debugging and the time needed trying to understand non-explanatory code must be held against the tiny calculation cost.

This sectionneeds additional citations forverification. Please helpimprove this article byadding citations to reliable sources in this section. Unsourced material may be challenged and removed.(March 2010) (Learn how and when to remove this message)

When a numeric literal lacks special meaning, then its use is not classified as magic; although what constitutes special is subjective. Examples of literals that are often not considered magic include:

• Use of 0 and 1 as initial or incremental values in afor loop, such asfor(inti=0;i<max;i+=1)

• Use of 2 to check whether a number is even or odd, as inisEven = (x % 2 == 0), where% is themodulo operator

• Use of simple literals, e.g., in expressions such ascircumference = 2 * Math.PI * radius,^[1] or for calculating thediscriminant of aquadratic equation asd = b^2 − 4*a*c

• Use of powers of 10 to convert metric values (e.g. between grams and kilograms) or to calculate percentage andper mille values

• Exponents in expressions such as(f(x) ** 2 + f(y) ** 2) ** 0.5 for${\displaystyle \sqrt{f(x{)}^2+f(y{)}^2}}$

• The literals 1 and 0 are sometimes used to represent theBoolean values true and false. Arguably, assigning these values to names such as TRUE and FALSE might be better.

• In C and C++, 0 is often used to meannull pointer even though the C standard library defines a macroNULL and modern C++ includes a keywordnullptr.

Format indicators were first used in earlyVersion 7 Unix source code.^{[citation needed]}

Unix was ported to one of the firstDECPDP-11/20s, which did not havememory protection. So early versions of Unix used therelocatable memory reference model.^[6] Pre-Sixth Edition Unix versions read an executable file intomemory and jumped to the first low memory address of the program,relative address zero. With the development ofpaged versions of Unix, aheader was created to describe theexecutable image components. Also, abranch instruction was inserted as the first word of the header to skip the header and start the program. In this way a program could be run in the older relocatable memory reference (regular) mode or in paged mode. As more executable formats were developed, new constants were added by incrementing the branchoffset.^[7]

In theSixth Editionsource code of the Unix program loader, the exec() function read the executable (binary) image from the file system. The first 8bytes of the file was aheader containing the sizes of the program (text) and initialized (global) data areas. Also, the first 16-bit word of the header was compared to twoconstants to determine if theexecutable image containedrelocatable memory references (normal), the newly implementedpaged read-only executable image, or the separated instruction and data paged image.^[8] There was no mention of the dual role of the header constant, but the high order byte of the constant was, in fact, theoperation code for the PDP-11 branch instruction (octal 000407 orhex 0107). Adding seven to the program counter showed that if this constant wasexecuted, it would branch the Unix exec() service over the executable image eight byte header and start the program.

Since the Sixth and Seventh Editions of Unix employed paging code, the dual role of the header constant was hidden. That is, the exec() service read the executable file header (meta) data into akernel space buffer, but read the executable image intouser space, thereby not using the constant's branching feature. Magic number creation was implemented in the Unixlinker andloader and magic number branching was probably still used in the suite ofstand-alonediagnostic programs that came with the Sixth and Seventh Editions. Thus, the header constant did provide an illusion and met the criteria formagic.

In Version Seven Unix, the header constant was not tested directly, but assigned to a variable labeledux_mag^[9] and subsequently referred to as themagic number. Probably because of its uniqueness, the termmagic number came to mean executable format type, then expanded to mean file system type, and expanded again to mean any type of file.

Magic numbers are common in programs across many operating systems. Magic numbers implementstrongly typed data and are a form ofin-band signaling to the controlling program that reads the data type(s) at program run-time. Many files have such constants that identify the contained data. Detecting such constants in files is a simple and effective way of distinguishing between manyfile formats and can yield further run-timeinformation.

Examples

• CompiledJava class files (bytecode) andMach-O binaries start with hexCA FE BA BE. When compressed withPack200 the bytes are changed toCA FE D0 0D.
• GIF image files have theASCII code for "GIF89a" (47 49 46 38 39 61) or "GIF87a" (47 49 46 38 37 61)
• JPEG image files begin withFF D8 and end withFF D9. JPEG/JFIF files contain thenull terminated string "JFIF" (4A 46 49 46 00). JPEG/Exif files contain thenull terminated string "Exif" (45 78 69 66 00), followed by moremetadata about the file.
• PNG image files begin with an 8-byte signature which identifies the file as a PNG file and allows detection of common file transfer problems: "\211PNG\r\n\032\n" (89 50 4E 47 0D 0A 1A 0A). That signature contains variousnewline characters to permit detecting unwarranted automated newline conversions, such as transferring the file usingFTP with theASCIItransfer mode instead of thebinary mode.^[10]
• StandardMIDI audio files have theASCII code for "MThd" (MIDITrackheader,4D 54 68 64) followed by more metadata.
• Unix orLinux scripts may start with ashebang ("#!",23 21) followed by the path to aninterpreter, if the interpreter is likely to be different from the one from which the script was invoked.
• ELF executables start with the byte7F followed by "ELF" (7F 45 4C 46).
• PostScript files and programs start with "%!" (25 21).
• PDF files start with "%PDF" (hex25 50 44 46).
• DOS MZ executable files and theEXE stub of theMicrosoft WindowsPE (Portable Executable) files start with the characters "MZ" (4D 5A), the initials of the designer of the file format,Mark Zbikowski. The definition allows the uncommon "ZM" (5A 4D) as well for dosZMXP, a non-PE EXE.^[11]
• TheBerkeley Fast File System superblock format is identified as either19 54 01 19 or01 19 54 depending on version; both represent the birthday of the author,Marshall Kirk McKusick.
• TheMaster Boot Record of bootable storage devices on almost allIA-32IBM PC compatibles has a code of55 AA as its last two bytes.
• Executables for theGame Boy andGame Boy Advance handheld video game systems have a 48-byte or 156-byte magic number, respectively, at a fixed spot in the header. This magic number encodes a bitmap of theNintendo logo.
• Amiga software executableHunk files running on Amiga classic68000 machines all started with the hexadecimal number $000003f3, nicknamed the "Magic Cookie."
• In the Amiga, the only absolute address in the system is hex $0000 0004 (memory location 4), which contains the start location called SysBase, a pointer to exec.library, the so-calledkernel of Amiga.
• PEF files, used by theclassic Mac OS andBeOS forPowerPC executables, contain theASCII code for "Joy!" (4A 6F 79 21) as a prefix.
• TIFF files begin with either "II" or "MM" followed by42 as a two-byte integer in little or bigendian byte ordering. "II" is for Intel, which useslittle endian byte ordering, so the magic number is49 49 2A 00. "MM" is for Motorola, which usesbig endian byte ordering, so the magic number is4D 4D 00 2A.
• Unicode text files encoded inUTF-16 often start with theByte Order Mark to detectendianness (FE FF for big endian andFF FE for little endian). And onMicrosoft Windows,UTF-8 text files often start with the UTF-8 encoding of the same character,EF BB BF.
• LLVM Bitcode files start with "BC" (42 43).
• WAD files start with "IWAD" or "PWAD" (forDoom), "WAD2" (forQuake) and "WAD3" (forHalf-Life).
• MicrosoftCompound File Binary Format (mostly known as one of the older formats ofMicrosoft Office documents) files start withD0 CF 11 E0, which is visually suggestive of the word "DOCFILE0".
• Headers inZIP files often show up in text editors as "PK♥♦" (50 4B 03 04), where "PK" are the initials ofPhil Katz, author ofDOS compression utilityPKZIP.
• Headers in7z files begin with "7z" (full magic number:37 7A BC AF 27 1C).

Detection

The Unix utility programfile can read and interpret magic numbers from files, and the file which is used to parse the information is calledmagic. The Windows utility TrID has a similar purpose.

Examples

• TheOSCAR protocol, used inAIM/ICQ, prefixes requests with2A.
• In theRFB protocol used byVNC, a client starts its conversation with a server by sending "RFB" (52 46 42, for "Remote Frame Buffer") followed by the client's protocol version number.
• In theSMB protocol used by Microsoft Windows, each SMB request or server reply begins withFF 53 4D 42, or\xFFSMB at the start of the SMB request.
• In theMSRPC protocol used by Microsoft Windows, each TCP-based request begins with05 at the start of the request (representing Microsoft DCE/RPC Version 5), followed immediately by a00 or01 for the minor version. In UDP-based MSRPC requests the first byte is always04.
• InCOM andDCOM marshalled interfaces, calledOBJREFs, always start with the byte sequence "MEOW" (4D 45 4F 57). Debugging extensions (used for DCOM channel hooking) are prefaced with the byte sequence "MARB" (4D 41 52 42).
• UnencryptedBitTorrent tracker requests begin with a single byte containing the value19 representing the header length, followed immediately by the phrase "BitTorrent protocol" at byte position 1.
• eDonkey2000/eMule traffic begins with a single byte representing the client version. CurrentlyE3 represents an eDonkey client,C5 represents eMule, andD4 represents compressed eMule.
• The first 4 bytes of a block in theBitcoin Blockchain contains a magic number which serves as the network identifier. The value isD9 B4 BE F9, which indicates the main network, whileDA B5 BF FA indicates the testnet.
• SSL transactions always begin with a "client hello" message. The record encapsulation scheme used to prefix all SSL packets consists of two- and three- byte header forms. Typically an SSL version 2 client hello message is prefixed with an80 and an SSLv3 server response to a client hello begins with16 (though this may vary).
• DHCP packets use a "magic cookie" value of63 82 53 63 at the start of the options section of the packet. This value is included in all DHCP packet types.
• HTTP/2 connections start with the 24-character stringPRI * HTTP/2.0\r\n\r\nSM\r\n\r\n. It is designed to avoid the processing of frames by servers and intermediaries which support earlier versions of HTTP but not 2.0.
• TheWebSocket opening handshake uses a string containing theUUIDv4258EAFA5-E914-47DA-95CA-C5AB0DC85B11.

Magic numbers are common inAPI functions andinterfaces across manyoperating systems, includingDOS,Windows andNetWare:

Examples

• IBM PC-compatibleBIOSes use magic values00 00 and12 34 to decide if the system should count up memory or not on reboot, thereby performing a cold or a warm boot. Theses values are also used byEMM386 memory managers intercepting boot requests.^[12] BIOSes also use magic values55 AA to determine if a disk is bootable.^[13]
• TheMS-DOS disk cacheSMARTDRV (codenamed "Bambi") uses magic valuesBA BE andEB AB in API functions.^[12]
• ManyDR-DOS,Novell DOS andOpenDOS drivers developed in the formerEuropean Development Centre in the UK use the value0E DC as magic token when invoking or providing additional functionality sitting on top of the (emulated) standard DOS functions, NWCACHE being one example.^[12]

Examples

• The defaultMAC address on Texas InstrumentsSOCs isDE:AD:BE:EF:00:00.^[14]

It is possible to create or alterglobally unique identifiers (GUIDs) so that they are memorable, but this is highly discouraged as it compromises their strength as near-unique identifiers.^[15][16] The specifications for generating GUIDs and UUIDs are quite complex, which is what leads to them being virtually unique, if properly implemented.^[17]

Microsoft Windows product ID numbers forMicrosoft Office products sometimes end with0000-0000-0000000FF1CE ("OFFICE"), such as90160000-008C-0000-0000-0000000FF1CE, the product ID for the "Office 16 Click-to-Run Extensibility Component".

Java uses several GUIDs starting withCAFEEFAC.^[18]

In theGUID Partition Table of the GPT partitioning scheme,BIOS Boot partitions use the special GUID21686148-6449-6E6F-744E-656564454649^[19] which does not follow the GUID definition; instead, it is formed by using theASCII codes for the stringHah!IdontNeedEFI partially inlittle endian order.^[20]

Magic debug values are specific values written tomemory duringallocation or deallocation, so that it will later be possible to tell whether or not they have become corrupted, and to make it obvious when values taken from uninitialized memory are being used. Memory is usually viewed in hexadecimal, so memorable repeating orhexspeak values are common. Numerically odd values may be preferred so that processors without byte addressing will fault when attempting to use them as pointers (which must fall at even addresses). Values should be chosen that are away from likely addresses (the program code, static data, heap data, or the stack). Similarly, they may be chosen so that they are not valid codes in the instruction set for the given architecture.

Since it is very unlikely, although possible, that a 32-bit integer would take this specific value, the appearance of such a number in adebugger ormemory dump most likely indicates an error such as a buffer overflow or anuninitialized variable.

Famous and common examples include:

Most of these are 32bits long – theword size of most 32-bit architecture computers.

The prevalence of these values in Microsoft technology is no coincidence; they are discussed in detail inSteve Maguire's bookWriting Solid Code fromMicrosoft Press. He gives a variety of criteria for these values, such as:

• They should not be useful; that is, most algorithms that operate on them should be expected to do something unusual. Numbers like zero don't fit this criterion.
• They should be easily recognized by the programmer as invalid values in the debugger.
• On machines that don't havebyte alignment, they should beodd numbers, so that dereferencing them as addresses causes an exception.
• They should cause an exception, or perhaps even a debugger break, if executed as code.

Since they were often used to mark areas of memory that were essentially empty, some of these terms came to be used in phrases meaning "gone, aborted, flushed from memory"; e.g. "Your program is DEADBEEF".^{[citation needed]}

• Magic string
• File format § Magic number
• List of file signatures
• FourCC
• Hard coding
• Magic (programming)
• NaN (Not a Number)
• Enumerated type
• Hexspeak, for another list of magic values
• Nothing up my sleeve number about magic constants incryptographic algorithms
• Time formatting and storage bugs, for problems that can be caused by magics
• Sentinel value (aka flag value, trip value, rogue value, signal value, dummy data)
• Canary value, special value to detect buffer overflows
• XYZZY (magic word)
• Fast inverse square root, an algorithm that uses the constant 0x5F3759DF

• Anti-patterns
• Debugging
• Computer programming folklore
• Software engineering folklore

• Articles with short description
• Short description is different from Wikidata
• Use dmy dates from July 2019
• Articles needing additional references from March 2010
• All articles needing additional references
• All articles with unsourced statements
• Articles with unsourced statements from November 2019
• Articles with unsourced statements from August 2025
• Articles with unsourced statements from June 2020