The transition to 64 bits is not just a hardware change; it has significant implications for the operation of software. If software is currently using 32 bits to store integers, it will malfunction if the processor is expecting 64 bits of information for each integer. At the lowest level, each 64 bit processor must be coupled with a 64-bit capable operating system. Currently, Windows XP supports 64 bits, but only if a special 64-bit version is purchased and installed. There are some Linux distributions that support 64 bits, and the latest versions of Mac OS support 64 bits. If a 64-bit processor, however, is installed in any other operating system, it will usually operate in a 32-bit compatibility mode. As 64-bit operating systems are relatively rare, the vast majority of home PC 64 bit processors today are operating in this manner.

64-bit Operating Systems

Windows XP x64

Windows Server 2003 x64

Red Hat Linux

Solaris 10

Mac Os X

Windows Longhorn 64-bit Edition

Non-64-bit Operating Systems

Windows XP

Windows Me

Windows 98 and older

Windows 2000 and older

Mac OS 9 and older

The uptake of 64-bit operating systems is fairly slow, as it poses serious compatibility issues between old hardware and software, and, as very few programs are designed for 64-bit computing, presents few advantages. Theoretically, Windows XP x64 should be able to run most 32-bit programs in a compatibility mode, but nevertheless a lot of complex programs, and programs that deal with hardware, are incompatible. For example, Windows XP x64 lacks many of the features of standard Windows XP, such as Windows Media Player, and is incompatible with most antivirus programs. Additionally, all drivers need to be special 64-bit versions. This means that users will have to download special drivers for all of their hardware, and because 64-bit computing is such a recent development, these drivers are often in beta phase and very buggy and unreliable.

"The biggest challenge is going to be the device drivers in 64-bit mode,"

- Microprocessor Report's Krewell

Converting an existing 32-bit program to 64 bits should be relatively simple. If the program is well coded, recompiling is all that is necessary. The compiler will do what is necessary to reflect the larger register size. Programs that deal directly with the memory, however, will experience problems. This is because the number of bytes occupied by variables and instructions will be different from 32-bit operation. Hence, if a program directly manipulates with the memory (as is common in pure C), bugs may arise.

Buggy Code

void* pointers = createPointerArray() ; //returns a address of an array of pointers

Buggy line: void* pointer2 = pointer1 + 4;

Good line: void* pointer2 = pointer1 + sizeOf(void*);

The size of a pointer is now 8 bytes, not 4, and hence if the number 4 is hard-coded into the program, a bug will arise. Using the sizeof() function is thus a much better alternative to hard coding numbers.