Advertising on the portal

Run a 32-bit to 64-bit program. Managing files and registry settings in WOW64

]. But 32-bit OSes are still present on the market in sufficient quantities. large quantities. Many modern software tools are developed exclusively to work in 64-bit mode, since ensuring the functionality of the program in both 32-bit and 64-bit OS requires additional labor costs and, accordingly, the cost of development increases.

For users of a 32-bit OS, sometimes there is a need to use software designed only for a 64-bit OS. What to do if the user is not ready to give up the 32-bit OS as the main working system?

Different operating systems have their own peculiarities related to running 64-bit applications in a 32-bit environment. When running a 64-bit application directly in a 32-bit environment, the advantage associated with the ability to use more RAM is lost. To support 64-bit applications, your processor must have a 64-bit architecture. Let's look at some of the most popular operating systems.

Mac OS X has a hybrid kernel. It allows any application to work the same, regardless of whether they are 32-bit or 64-bit. The only difference between a hybrid kernel and a full 64-bit one is the inability to use more than 32 GB of RAM in the system. Therefore, at the moment there is absolutely no difference between booting in 32-bit and 64-bit modes. But in the future, the difference will definitely appear as the volume of RAM usage increases and new technologies emerge.

For operating systems of the Linux family and 32-bit operating systems of the Windows family, running 64-bit applications in a 32-bit environment is carried out using virtualization technologies. There are a number of specialized software products that allow you to install a virtual guest 64-bit OS, into which you can install the application you require and launch it. At the same time, if the installed OS is paid, then you will be forced to buy it.

Virtualization

How to run the game on a 32-bit system if it requires a 64-bit system, instructions.

You probably want to know how to consistently earn money online from 500 rubles a day?
Download my free book
=>>

To use many modern programs, including games, a 64-bit system is required. Therefore, owners of a PC with a 32-bit system, when trying to launch some programs, may encounter an error such as “The version of this file is incompatible with the version of Windows you are using...”.

An error like this indicates that the game you are trying to install on your PC is designed for a 64-bit system and not a 32-bit one. The fact is that, unlike a 64-bit system, a 32-bit system can run programs developed only for it.

Therefore, if you are in doubt or do not know the bitness of your OS, then you can find out as follows:

  • Through “Start”, enter “Control Panel”.
  • Select the “System and Security” section and click on “System”.
  • Opposite the line with the name “System type” there will be its bit capacity.

How to run a game on a 32-bit system if it requires a 64-bit one

If it turns out that the OS is 32-bit, and you need to install a 64-bit one, then it is not necessary to reinstall Windows. It is exactly how to solve such a problem that will be discussed in more detail in this article.

Differences between 64-bit and 32-bit systems

First of all, it is worth understanding that what kind of system is used depends total volume RAM on the computer. In addition, how much space can be allocated for a specific application depends on the capacity of the system.

Thus, when using a 64-bit system, the maximum amount of RAM (random access memory) is 16 GB. At the same time, in Windows Professional, this indicator can reach 192 GB. In turn, up to 4 GB of RAM is allocated for any specific utility.

If we consider x32, then the RAM in this case is much less. The maximum amount of RAM is 4 GB. As for individual applications, a maximum of 2 GB can be allocated for them.

Also, the speed of data processing also depends on the bit capacity of the processor. That is, in the case of x64, the load is distributed evenly across all PC cores. And in x32, the second core starts only after the first one is fully loaded.

In addition, there is another rather important point - a 64-bit system is not suitable for weak PCs. Therefore, when buying a computer, it is better to immediately purchase x64, since this option can run any applications. Even those designed for 32-bit systems.

However, if you do not want to do this or there is simply no such opportunity, then you can use third party program or remote servers.

Programs for creating a guest OS

There are utilities that allow you to emulate the operation of systems that contain certain software and hardware. However, in this case, it is recommended to use only licensed versions of visualization programs.

The operation of such utilities is based on the creation of a so-called guest version of the OS. Moreover, to create it you will need a disk or its image with the required OS.

Among the programs that allow you to create a guest operating system are:

  • Oracle VirtualBox.
  • VMware Worstation.
  • Windows Virtual PC, etc.

Remote servers

This option of using remote servers to run games that require a 64-bit OS is also quite convenient, as are special utilities. Only when using a remote server, all calculations and information will be processed exclusively on it.

The essence this option is that you will not be hampered by the limitations that you may encounter on x32 OS. Since games and other programs will run on the systems they require.

For example, a program such as Microsoft Azure allows you to create several operating systems at once. For those who love gaming, you can use NVIDIA GRID. With its help, the video card is virtualized.

Just remember that these services work with remote servers. Accordingly, a good Internet connection is required for their normal functioning.

Resume

When faced with the question of how to run a game on a 32-bit system if it requires a 64-bit one, it is quite possible to solve it. Only for this, as you can see, you will need to work with specialized programs or remote servers. And this is quite difficult.

Also, do not forget about the risk of infecting your PC with malware. Therefore, if your computer allows it, then it is better to install a 64-bit OS. In this case, you will not have problems launching programs and games.

But remember that the choice is always yours. But not all PCs can run a 64-bit OS.

Useful articles:

P.S. I am attaching a screenshot of my earnings in affiliate programs. And I remind you that anyone can earn money this way, even a beginner! The main thing is to do it correctly, which means learning from those who are already making money, that is, from Internet business professionals.


Get a list of proven, especially current, Affiliate Programs in 2018 that pay money!


Download the checklist and valuable bonuses for free
=>> “The best affiliate programs of 2018”

Most modern games like Overwatch, Hurtworld or Subnautica can only run on 64-bit operating systems. It is simply not profitable for the creators of these programs to make different versions of applications for 32- and 64-bit. Although both versions are quite common. Of course, switching to x64 is quite easy. But what if you are not going to change the OS and still want to watch a popular game? Learn how to run Subnautica and other 64-bit programs on a 32-bit system.

To do this, the computer must meet the requirements necessary for normal operation applications. The processor must initially have x64 architecture.

What is the difference between a 32-bit system and a 64-bit one?

Why can’t programs designed for 64 bit open on 32 bit? Why are these versions so different, since they do not run the same applications? And if Overwatch can be played on x64, why can't it be played on the same computer, but with x32?

It depends on the system how much RAM can be installed on a PC and how much it can allocate to each specific application. In x64, the maximum amount of RAM is 16 GB (in Windows 7 Professional - up to 192 GB). In this case, any utility is provided with up to 4 GB. In the x32 version, the indicated numbers are much smaller - 4 GB maximum and 2 GB for a separate program.

The capacity of the processor determines how it processes information. This significantly affects performance - it is much better in 64 bit. There is a larger register for storing data, and the load is distributed across all cores at once. And in a 32-bit OS, the second core is activated when the first is fully occupied.

On “weak” machines install x32. If your PC doesn't have a lot of RAM and doesn't have the best processor, there's simply no point in running 64 bit. This will only “overload” the electronic computer without adding productivity to it. But a powerful x64 computer will be just right.

Although these systems are superficially similar to each other, they are very different at the software level. They have a different set of drivers, so Subnautica, Overwatch, Hurtworld and others like that will not run on a 32-bit OS, even if the PC has the necessary characteristics.

For modern games, applications, graphics or video editing programs, the 2 GB that x32 allocates to them is not enough. Composers of new games create their products specifically for x64.

How to find out if a processor supports x64?

You can see what OS you have installed like this:

  1. On your desktop, right-click on the “My Computer” icon.
  2. “Properties” item. It can also be found in the Control Panel section.
  3. The "Type" line will indicate how many bits there are in your OS version.

First you need to understand what system you are working on.

Before you run Overwatch on a 32-bit system, find out if your PC can handle the game. Check if the processor supports 64-bit instructions. This can be done using special tester programs. For example, the free utility “SecurAble” is suitable. It doesn't need to be installed. And, accordingly, there is no need to remove it after use. Just run the executable. Information about the processor will be shown: name, clock speed, bit depth, whether it supports D.E.P (this protects the device from buffer overflow) and hardware visualization. You can click on any of the results and its description will appear.

Checking processor support for 64-bit commands

If the program returns a verdict of “Maximum 32 bit,” it means that applications designed for x64 are unlikely to work. To play Overwatch or Hurtword, you will have to change the processor or dispose of remote servers.

How to turn a 32-bit system into a 64-bit one?

There are several utilities for so-called virtualization. They emulate the operation of a platform with certain software and hardware. If you need to figure out how to run Hurtworld on a 32-bit system, use one of these utilities.

These programs create a kind of “guest” OS. But you must install it in any case and purchase a licensed version if it is paid. To do this, you must have a disk (or disk image) with the operating system that you need.

Oracle VirtualBox

A universal program for similar tasks.

  1. Install it and run it. On the left there will be a list of installed operating systems and a toolbar. On the right is information about the selected system.
  2. Click the "Create" button. An information window will appear. Click "Next".
  3. Select OS type and version. There are many options to choose from: not only Microsoft windows, but also Linux.
  4. Then you will need to decide how much RAM to allocate to the “guest” system.
  5. After this, you need to create a virtual disk (to which the OS files will be written). You can choose an existing one or make a new one. And check the box next to the option “ Boot disk».
  6. In the next window, select whether the disk capacity will be fixed or dynamic (changing). There are detailed explanations for each item. It is better to make the boot one fixed. You can add more drives later.
  7. Configure the virtual storage size. Usually 10 GB is enough. It is better to create it in a separate place - not in the same place where the main system is installed.
  8. Wait for the process to complete. A new one will appear in the list of available ones.

One way is to use virtualization utilities

Afterwards you can configure the hardware:

  1. Select the guest OS and click Properties.
  2. In the General - Advanced section, change the folder for saving pictures to the one that is convenient for you.
  3. Set up the clipboard there. It determines how information will be transferred between different operating systems.
  4. In the “System” tab you can select the characteristics of the virtual motherboard and processor.
  5. The “Network” item is needed to configure access to world wide web. You can leave the default settings.
  6. In the “Media” section, indicate where you want to get the OS from. If the installer is on a CD, insert it into your drive. To download from .ISO, click on the “Open” button next to the “Drive” list. It looks like a yellow folder.
  7. You can also add other images there to quickly switch between them: databases, applications, games.

After completing the settings, click “OK”. To start the guest OS, click on it and the “Start” button. The installation will proceed. And you can switch between systems: play in 64-bit and work in 32-bit.

Other virtual machines

There are also utilities for working with virtual machines:

  • VMware Workstation. Serious professional program for complex tasks. It extends to on a paid basis.
  • A simple utility for hardware emulation. Has an open source code.
  • windows Virtual PC. Works only with Windows systems. You can configure the priority of processes - this way resources will be automatically allocated to the online machine if it performs a certain task.
  • Virt-Manager. Provides ample opportunities for customizing the hardware component - virtual hardware is available for every taste.

Cloud computing (remote servers)

If the performance is still not enough to run the game, you can do it on a remote server. All calculations, all information will be processed on it. This way you won't be hindered by any limitations associated with x32. After all, in essence, applications will “open” on suitable systems. Just not on your computer.

The Microsoft Azure program is suitable for this. With its help, you can create several operating systems for different purposes. Game lovers will also find the specialized NVIDIA GRID video card virtualization service useful. These utilities require high-speed Internet.

Cutting-edge cloud services expand our capabilities

Working with 64-bit applications on a 32-bit system is quite possible. But you need to install additional software or, in general, switch to remote server. This is quite difficult to do. If you want to fully play Overwatch, Hurtword and other popular games, it is better to install x64 OS. This way there will be no compatibility problems. And you won't have to configure anything.

NastroyVse.ru

windows x64 - Why are there still so many 32-bit programs?

Your computer is most likely running a 64-bit version of Windows. But if you open Task Manager, you will see that most of the programs on your system are still 32-bit. Is this really a problem? There are many differences between 64-bit and 32-bit versions of windows. 64-bit versions of windows can run 32-bit software, but 32-bit versions of windows cannot run 64-bit software.

How to find out the bit depth of a program?

Let's use Task Manager to see which of your programs are 64-bit and which are 32-bit. Right-click on the taskbar and select Task Manager or press Ctrl + Shift + Esc to open it. Look at the column with process names. If you are using the 64-bit version of Windows 8.1 or 8, you will see the word “(32-bit)” after each 32-bit version of the program name. If you are using the 64-bit version of Windows 7, you will see “*32” instead. 32-bit programs are typically installed in the C:\Program Files (x86)\ folder on 64-bit versions of windows, while 64-bit programs are typically installed in the C:\Program Files\ folder. It's just a rule. But no one is saying that there is no other rule that prohibits installing 64-bit programs in the C:\Program Files (x86)\ folder. For example, Steam is a 32-bit program, so it installs in "C:\Program Files (x86)\" by default. The games you install on Steam are installed in the C:\Program Files (x86)\Steam folder by default, incl. even 64-bit versions of games. If you compare two different Program Files folders, you will find that most of your programs are most likely installed in the C:\Program Files (x86) folder. And, these programs are mostly 32-bit.

Running 32-bit software on a 64-bit operating system

At first glance, it seems terrible that most of your Windows programs do not use 64-bit architecture operating system. You might think that there is a performance penalty for running 32-bit programs on a 64-bit operating system, but this is not the case. windows runs 32-bit programs through the WoW64 compatibility level on 64-bit versions of windows. However, 64-bit Intel processors and AMD are backward compatible and can directly run 32-bit software. All your 32-bit Windows programs will run just as they would on a 32-bit version of Windows. Thus, there is no obstacle to running these programs on a 64-bit operating system. Even if every program you use is still 32-bit, you will benefit because your operating system itself will be running in 64-bit mode. And, the 64-bit version of Windows is more secure.

64-bit programs and 32-bit programs: which is better?

32-bit programs run without problems on 64-bit versions of Windows operating systems. But would it be better if all your programs were 64-bit? There are definitely advantages to 64-bit programs. 32-bit programs can only use 2 GB of memory, while 64-bit programs can use much more. If the program is likely to come under attack, additional features security measures applied to 64-bit programs can help. Google Chrome is currently a 32-bit application even on 64-bit versions of Windows OS, but a 64-bit beta version of this program has already appeared. And Google promises that the 64-bit version of Chrome will be faster, more secure and more stable. Some programs offer 64-bit versions. For example: Photoshop, iTunes, Microsoft Office, and some of the most popular programs for windows, and all of them are available in 64-bit form. Latest games are also often 64-bit so they can use more than 2GB of memory. Many programs haven't made the transition to 64-bit, and most never will. You can still run most 32-bit Windows programs today, even those that were released ten years ago, on a 64-bit version of Windows, even if their developers have already updated them. A developer who wants to provide a 64-bit version of their program must do a lot of extra work. He must ensure that the existing code compiles and runs correctly as 64-bit software. It must provide and support two separate versions of the program, since users running a 32-bit version of Windows cannot use the 64-bit version. Let's take Evernote as an example. desktop version windows. Even if they released a 64-bit version of Evernote, users would likely not notice the difference at all. A 32-bit program can run just fine on a 64-bit version of Windows, and if there are no noticeable benefits, then there is no point in having a 64-bit version.

Where to find 64-bit applications

You generally will not be able to choose between 32-bit and 64-bit versions of the software. For example, when you install iTunes for Windows, Apple's website automatically directs you to either the 32-bit or 64-bit version of the installer, depending on your version of Windows. When installing Photoshop for Windows, both 32-bit and 64-bit executable files are usually installed. Photoshop automatically selects from them. Sometimes you may see separate download links for 32-bit and 64-bit versions of programs, but this is not that common. The important thing is not to search for 64-bit applications, but to find applications that work well for you. For most applications, it doesn't really matter whether the version is 64-bit or 32-bit.

It's easy to wonder why so many applications are still 32-bit when you open your task manager. But this is not a very big problem and here's why. Because most applications do not gain anything when switching to 64-bit editions of programs. Even if the developers did all the work and released 64-bit versions of all the little desktop applications and utilities you use on Windows, you wouldn't be able to tell the difference for most of them.

itchief.ru

7 steps to transfer a program to a 64-bit system

The article discusses the main steps to ensure correct transfer of 32-bit windows applications on 64-bit Windows systems. Although the article is aimed at developers using the C/C++ language in Visual Studio 2005/2008, it will also be useful to other developers planning to port their applications to 64-bit systems. The article describes the main points faced by developers planning to migrate 32-bit programs to 64-bit systems. Of course, the list of issues considered is not complete, but I would like to hope that over time an expanded version of this article will be offered. The author will be grateful for feedback, comments and questions that will improve the information content of this article. In computing architecture, the term "64-bit" refers to 64-bit integers and other data types that are 64 bits in size. “64-bit” systems can mean 64-bit microprocessor architectures (for example, EM64T, IA-64) or 64-bit operating systems (for example, windows XP Professional x64 Edition). AMD64 (aka x86-64, Intel 64, EM64T, x64) is a 64-bit microprocessor architecture and corresponding instruction set developed by AMD. This instruction set was licensed by Intel under the name EM64T (Intel64). The AMD64 architecture is an extension of the x86 architecture with full backward compatibility. Architecture received widespread as a base for personal computers and workstations. IA-64 is a 64-bit microprocessor architecture jointly developed by Intel and Hewlett Packard. Implemented in Itanium and Itanium 2 microprocessors. The architecture is used mainly in multiprocessor servers and cluster systems. AMD64 and IA-64 are two different 64-bit architectures that are not compatible with each other. Therefore, developers should immediately decide whether they need to support both of these architectures or just one. In most cases, unless you are developing highly specialized software for cluster systems or implementing your own high-performance DBMS, then most likely you only need to implement support for the AMD64 architecture, which is much more widespread than IA-64. This is especially true for software for the personal computer market, which is almost 100 percent occupied by the AMD64 architecture. Further in the article we will talk only about the AMD64 architecture (EM64T, x64), since its use is now most relevant for application software developers.

Speaking about various architectures, we should mention the concept of “Data Model”. A data model should be understood as a relationship between the dimensions of types accepted within the development environment. For one operating system, there may be several development tools that adhere to different data models. But usually only one model prevails, the one that best matches the hardware and software environment. An example is the 64-bit Windows operating system, in which the native data model is LLP64. But for compatibility, the 64-bit Windows system supports the execution of 32-bit programs that run in the ILP32LL data model mode. Table N1 provides information about the main data models.


Table N1. Data Models

The data model used affects the development process of 64-bit applications, since the program code must take into account the bit depth of the data used.

You should start mastering 64-bit systems with the question “Do we need to rebuild our project for a 64-bit system?” This question must be answered, but not in a hurry, after thinking. On the one hand, you can fall behind your competitors by not offering 64-bit solutions on time. On the other hand, you can waste time on a 64-bit application that will not give any competitive advantages. We list the main factors that will help you make a choice. You should not create a 64-bit version of an application with a short life cycle. Thanks to the WOW64 subsystem, old 32-bit applications work quite well on 64-bit Windows systems and therefore it makes no sense to make a 64-bit program that will no longer be supported in 2 years. Moreover, practice has shown that the transition to 64-bit versions of Windows has been delayed and perhaps the majority of your users in the short term will use only the 32-bit version of your software solution. If you plan for long-term development and long-term support of a software product, then you should start working on the 64-bit version of your solution. This can be done slowly, but keep in mind that the longer you do not have a full-fledged 64-bit version, the more difficulties may arise with supporting such an application installed on 64-bit versions of Windows. Recompiling the program for a 64-bit system will allow it to use huge amounts of RAM, and will also speed up its operation by 5-15%. A 5-10% speedup will occur due to the use of architectural capabilities of a 64-bit processor, for example, a larger number of registers. Another 1%-5% increase in speed is due to the absence of the WOW64 layer, which translates API calls between 32-bit applications and the 64-bit operating system. If your program does not work with large amounts of data (more than 2GB) and its speed is not critical, then switching to a 64-bit system in the near future is not so relevant. By the way, even simple 32-bit applications can benefit from running them in a 64-bit environment. You probably know that a program compiled with the /LARGEADDRESSAWARE:YES key can allocate up to 3 gigabytes of memory if the 32-bit Windows operating system is launched with the /3gb key. The same 32-bit program running on a 64-bit system can allocate almost 4 GB of memory (in practice, about 3.5 GB). If you develop libraries, components, or other elements that third-party developers use to create their software, then you must be proactive in creating a 64-bit version of your product. Otherwise, your customers interested in releasing 64-bit versions will be forced to look for alternative solutions. For example, some software and hardware protection developers responded with a long delay to the emergence of 64-bit programs, which forced a number of clients to look for other tools to protect their programs. Additional benefit from releasing a 64-bit version of the library is that you can sell it as separate product. Thus, your customers who want to create both 32-bit and 64-bit applications will be forced to purchase 2 different licenses. For example, this policy is used by Spatial Corporation when selling the Spatial ACIS library. Before you plan to create 64-bit versions of your product, find out whether there are 64-bit versions of the libraries and components that it uses. Also find out what pricing policy in relation to the 64-bit version of the library. All this can be found out by visiting the website of the library developer. If support is not available, then look in advance for alternative solutions that support 64-bit systems. If your solutions still contain 16-bit modules, then it's time to get rid of them. Running 16-bit applications on 64-bit versions of Windows is not supported. Here we should clarify one point related to the use of 16-bit installers. They are still used to install some 32-bit applications. A special mechanism has been created that on the fly replaces a number of the most popular 16-bit installers with newer versions. This may cause the misconception that 16-bit programs still run in a 64-bit environment. Remember, this is not true. Don't forget that using a large amount of assembly code can significantly increase the cost of creating a 64-bit version of the application. After weighing all the listed facts, all the pros and cons, decide whether you should port your project to 64-bit systems. And if that's the case, then let's move on. Just because you've decided to develop a 64-bit version of your product and are willing to spend time on it doesn't guarantee success. The fact is that you must have all the necessary tools and there may be unpleasant incidents here.

The simplest, but also the most insurmountable, problem may be the lack of a 64-bit compiler. The article is written in 2009, but there is still no 64-bit C++ Builder compiler from Codegear. Its release is expected only by the end of this year. It is impossible to get around a similar problem, unless, of course, you rewrite the entire project, for example, using Visual Studio. But if everything is clear with the lack of a 64-bit compiler, then other similar problems may turn out to be more hidden and emerge already at the stage of work on transferring the project to a new architecture. Therefore, I would like to advise you to conduct research in advance to determine whether all the necessary components exist that will be required to implement the 64-bit version of your product. Unpleasant surprises may await you.

Of course, it is impossible to list everything that may be needed for a project here, but I will still offer a list that will help you get your bearings and perhaps remember other points that are necessary for the implementation of your 64-bit project: It is difficult to say anything else about the importance of having 64-bit compiler. It just has to be. If you plan to develop 64-bit applications using the latest version (at the time of writing) of Visual Studio 2008, then the following table N2 will help determine which edition of Visual Studio you need.

Table N2. Capabilities of different editions of Visual Studio 2008 You can, of course, use virtual machines to run 64-bit applications on 32-bit hardware, but this is extremely inconvenient and will not provide the required level of testing. It is advisable that machines have at least 4-8 gigabytes of RAM installed. If libraries are provided in source code, then a 64-bit project configuration must be present. Upgrading a library yourself to build it for a 64-bit system can be a thankless and difficult task, and the result can be unreliable and error-prone. You may also violate license agreements by doing so. If you are using libraries as binary modules, then you should also find out if 64-bit modules exist. You won't be able to use 32-bit DLLs inside a 64-bit application. You can create a special harness via COM, but this will be a separate large one, challenging task. Also note that purchasing the 64-bit version of the library may cost extra money . Visual C++ does not support 64-bit inline assembler. You must use either an external 64-bit assembler (for example, MASM) or have a C/C++ implementation of the same functionality. Significant revision of testing methodology, modernization of unit tests, use of new tools. This will be discussed in more detail below, but do not forget to take this into account when estimating the time spent migrating an application to a new system. If you are developing resource-intensive applications that consume a large amount of RAM, then you need to take care of replenishing the database of test input data. When load testing 64-bit applications, it is advisable to go beyond 4 gigabytes of memory consumption. Many errors can only appear under such conditions. The protection system used must support 64-bit systems to the full extent you require. For example, Aladdin quickly released 64-bit drivers to support Hasp hardware keys. But for a very long time there was no system for automatic protection of 64-bit binary files (Hasp Envelop program). Thus, the protection mechanism had to be implemented independently within the program code, which was an additional complex task that required qualifications and time. Don’t forget about similar issues related to security, the update system, and so on. You need a new installer that can fully install 64-bit applications. I would like to immediately warn you about one traditional mistake. This is the creation of 64-bit installers for installing 32/64-bit software products. When preparing a 64-bit version of an application, developers often want to make it completely 64-bit. And they create a 64-bit installer, forgetting that users of a 32-bit operating system simply will not run such an installation package. Please note that it is not the 32-bit application included in the distribution along with the 64-bit that will not start, but the installer itself. After all, if the distribution is a 64-bit application, then, of course, it will not run on a 32-bit operating system. The most annoying thing about this is that the user will not be able to guess what is happening. He will simply see an installation package that cannot be launched. Creating a 64-bit project configuration in Visual Studio 2005/2008 looks quite simple. Difficulties will await you at the stage of assembling a new configuration and searching for errors in it. To create a 64-bit configuration, just complete the following 4 steps: Launch the configuration manager, as shown in Figure N1:

Figure 1. Launching the configuration manager In the configuration manager, select support for the new platform (Figure N2): Figure 2. Creating a new configuration Select the 64-bit platform (x64), and select the settings from the 32-bit version as the basis (Figure N3). The Visual Studio environment will adjust the settings that affect the build mode itself.

Figure 3. Select x64 as the platform and use the Win32 configuration as a basis. Adding a new configuration is completed, and we can select the 64-bit configuration option and begin compiling the 64-bit application. The choice of 64-bit configuration for assembly is shown in Figure N4. Figure 4. 32-bit and 64-bit configurations are now available. If you are lucky, there will be no need to additionally configure a 64-bit project. But this greatly depends on the project, its complexity and the number of libraries used. The only thing that needs to be changed right away is the stack size. If your project uses a default stack size, that is, 1 megabyte, then it makes sense to set it to 2 megabytes for the 64-bit version. This is not necessary, but it is better to be on the safe side in advance. If you use a stack size different from the default size, then it makes sense to make it 2 times larger for the 64-bit version. To do this, in the project settings, find and change the Stack Reserve Size and Stack Commit Size parameters. It would be good to talk here about typical problems, arising at the compilation stage of the 64-bit configuration. Consider what problems arise with third-party libraries, tell that the compiler in the code associated with WInAPI functions will no longer allow placing a pointer in the LONG type and you will need to modernize your code and use the LONG_PTG type. And much, much more. Unfortunately, there is so much of this and the errors are so varied that it is not possible to present it in one article or even, perhaps, a book. You will have to look through all the errors that the compiler will produce and new warnings that were not there before and in each individual case figure out how to modernize the code.

A collection of links to resources dedicated to the development of 64-bit applications can make life partly easier: http://www.viva64.com/links/64-bit-development/. The collection is constantly being updated and the author will be grateful to readers if they send him links to resources that, in their opinion, deserve attention.

We will focus here only on the types that may be of interest to developers when migrating applications. These types are presented in Table N3. Most compilation errors will be associated with the use of these types.

Type Dimensiontype on platform x32 / x64 Note
int 32 / 32 Basic type. On 64-bit systems it remains 32-bit.
long 32 / 32 Basic type. On 64-bit Windows systems it remains 32-bit. Please note that on 64-bit Linux systems this type has been extended to 64-bit. Don't forget about this if you are developing code that should work and compile for Windows and Linux systems.
size_t 32 / 64 Basic unsigned type. The size of the type is chosen so that it can be written to maximum size theoretically possible array. A pointer can be safely placed into the type size_t (the exception is pointers to class functions, but this is a special case).
ptrdiff_t 32 / 64 Similar to the size_t type, but signed. The result of an expression where one pointer is subtracted from another (ptr1-ptr2) will be of type ptrdiff_t.
Pointer 32 / 64 The size of the pointer directly depends on the bit capacity of the platform. Be careful when casting pointers to other types.
__int64 64 / 64 Signed 64-bit type.
DWORD 32 / 32 32-bit unsigned type. Declared in WinDef.h as: typedef unsigned long DWORD;
DWORDLONG 64 / 64 64-bit unsigned type. Declared in WinNT.h as: typedef ULONGLONG DWORDLONG;
DWORD_PTR 32 / 64 An unsigned type that can hold a pointer. Declared in BaseTsd.h as: typedef ULONG_PTR DWORD_PTR;
DWORD32 32 / 32 32-bit unsigned type. Declared in BaseTsd.h as: typedef unsigned int DWORD32;
DWORD64 64 / 64 64-bit unsigned type. Declared in BaseTsd.h as: typedef unsigned __int64 DWORD64;
HALF_PTR 16 / 32 Half a pointer. Declared in Basetd.h as:#ifdef _WIN64 typedef int HALF_PTR;#else typedef short HALF_PTR;#endif
INT_PTR 32 / 64 A signed type into which a pointer can be placed. Declared in BaseTsd.h as:#if defined(_WIN64) typedef __int64 INT_PTR; #else typedef int INT_PTR;#endif
LONG 32 / 32 A signed type that remains 32-bit. Therefore, in many cases LONG_PTR should now be used. Declared in WinNT.h as: typedef long LONG;
LONG_PTR 32 / 64 A signed type into which a pointer can be placed. Declared in BaseTsd.h as:#if defined(_WIN64) typedef __int64 LONG_PTR; #else typedef long LONG_PTR;#endif
LPARAM 32 / 64 Option for sending messages. Declared in WinNT.h as: typedef LONG_PTR LPARAM;
SIZE_T 32 / 64 Analogous to the size_t type. Declared in BaseTsd.h as: typedef ULONG_PTR SIZE_T;
SSIZE_T 32 / 64 Analogous to the ptrdiff_t type. Declared in BaseTsd.h as: typedef LONG_PTR SSIZE_T;
ULONG_PTR 32 / 64 An unsigned type that can hold a pointer. Declared in BaseTsd.h as:#if defined(_WIN64) typedef unsigned __int64 ULONG_PTR;#else typedef unsigned long ULONG_PTR;#endif
WORD 16 / 16 Unsigned 16-bit type. Declared in WinDef.h as: typedef unsigned short WORD;
WPARAM 32 / 64 Parameter for sending messages. Declared in WinDef.h as: typedef UINT_PTR WPARAM;
Table N3. Types of interest when porting 32-bit programs to 64-bit Windows systems. If you think that after correcting all compilation errors the long-awaited 64-bit application will be obtained, then you will have to be disappointed. The hardest part is yet to come. At the compilation stage, you will correct the most obvious errors that the compiler could detect, which are mainly related to the impossibility of implicit type casting. But this is the tip of the iceberg. Most of the errors are hidden. From the point of view of the abstract C++ language, these errors look safe or are disguised by explicit type casts. There are several times more such errors than the number of errors identified at the compilation stage.

You shouldn't pin your hopes on the /Wp64 key. This key is often touted as a miracle tool for finding 64-bit errors. In fact, the /Wp64 switch only makes it possible, when compiling 32-bit code, to receive some warnings that certain sections of the code will be incorrect in 64-bit mode. When compiling 64-bit code, these warnings will be issued by the compiler in any case. And therefore, when compiling a 64-bit application, the /Wp64 key is ignored. And even more so, this key will not help in finding hidden errors.

Let's look at a few examples of hidden errors. The simplest, but not the easiest to detect, class of errors is associated with explicit type casting, in which significant bits are cut off. A common example is casting pointers to 32-bit types when passing them to functions such as SendMessage:

MyObj* pObj = ... ::SendMessage(hwnd, msg, (WORD)x, (DWORD)pObj);
Here an explicit type cast is used to convert a pointer to a numeric type. For a 32-bit architecture, the above example is correct, since the last parameter of the SendMessage function is of type LPARAM, which is the same as DWORD on a 32-bit architecture. For 64-bit architecture, the use of DWORD is erroneous and should be replaced with LPARAM. The LPARAM type has a size of 32 or 64 bits, depending on the architecture.

This is a simple case, but often the type cast looks more sophisticated and cannot be detected using compiler warnings or searching through the program text. Explicit type casts suppress compiler diagnostics because they are intended to tell the compiler that the type cast is correct and the programmer has accepted responsibility for the safety of the code. An explicit search won't help either. Types may not have standard names (specified by the programmer via typedef), and there are also quite a few ways to implement explicit type casting. For reliable diagnostics To detect such errors, you need to use only special tools, such as Viva64 or PC-Lint analyzers.

Next example is already associated with an implicit type conversion, which also results in loss of significant bits. The fread function code reads from a file, but is incorrect when trying to read more than 2 gigabytes of data on a 64-bit system.

size_t __fread(void * __restrict buf, size_t size, size_t count, FILE * __restrict fp); size_t fread(void * __restrict buf, size_t size, size_t count, FILE * __restrict fp) ( int ret; FLOCKFILE(fp); ret = __fread(buf, size, count, fp); FUNLOCKFILE(fp); return (ret) ; )
The __fread function returns a size_t type, but the int type is used to store the number of bytes read. As a result, with large amounts of data being read, the function may return a different number of bytes than will actually be read. You can say that this is illiterate code for beginners, that the compiler will report such a type cast, and that in general such code is easy to find and correct. This is theoretical. But in real life, with large projects, everything can be different. This example is taken from the FreeBSD source code. The error was corrected only in December 2008! This is despite the fact that the first (experimental) 64-bit version of FreeBSD was released back in June 2003. Here is the source code before the fix:

http://www.freebsd.org/cgi/cvsweb.cgi/src/lib/libc/stdio/fread.c?rev=1.14

And here is the corrected version (December 2008):

http://www.freebsd.org/cgi/cvsweb.cgi/src/lib/libc/stdio/fread.c?rev=1.15

It's easy to make mistakes in code that works with individual bits. The next type of error is associated with shift operations. Let's look at an example:

ptrdiff_t SetBitN(ptrdiff_t value, unsigned bitNum) ( ptrdiff_t mask = 1
The above code works on a 32-bit architecture and allows you to set bits numbered 0 to 31 to one. After transferring the program to a 64-bit platform, it will be necessary to set bits from 0 to 63. But this code will never expose bits numbered 32-63. Please note that “1” is of type int and when shifted by 32 positions an overflow will occur, as shown in Figure 5. Whether the result is 0 (Figure 5-B) or 1 (Figure 5-C) depends on the compiler implementation.

Figure 5. A - Correct installation of the 31st bit in a 32-bit code; B,C - Error setting the 32nd bit on a 64-bit system (two behavior options) To correct the code, you need to make a constant “1” of the same type as the mask variable:

ptrdiff_t mask = ptrdiff_t(1)
Note also that uncorrected code will lead to another interesting bug. When setting 31 bits on a 64-bit system, the result of the function will be the value 0xffffffff80000000 (see Figure 6). The result of expression 1 size_t ArraySize = N * 4; size_t *Array = (size_t *)malloc(ArraySize); The main numbers that should be taken with caution when switching to a 64-bit platform are given in Table N4.

Table N4. The main magic values ​​that are dangerous when migrating applications from a 32-bit to a 64-bit platform In programs that process large amounts of data, errors associated with indexing large arrays may occur or eternal loops may occur. The following example contains 2 errors at once:

const size_t size = ...; char *array = ...; char *end = array + size; for (unsigned i = 0; i != size; ++i) ( const int one = 1; end[-i - one] = 0; )
The first error is that if the size of the processed data exceeds 4 gigabytes (0xFFFFFFFF), then an eternal loop may occur, since the variable "i" is of type "unsigned" and will never reach the value 0xFFFFFFFF. I specifically write that the occurrence is possible, but it will not necessarily happen. It depends on what code the compiler builds. For example, in debug mode the eternal loop will be present, but in the release code the looping will disappear, so the compiler will decide to optimize the code using a 64-bit register for the counter and the loop will be correct. All this adds to the confusion, and code that worked yesterday may suddenly stop working the next day. The second error is related to passing through the array from end to beginning, for which they are used negative values indexes. The above code works in 32-bit mode, but when it is run on a 64-bit machine, on the very first iteration of the loop, the array will be accessed beyond the boundaries and the program will crash. Let's consider the reason for this behavior. According to the C++ language rule on a 32-bit system, the expression “-i - one” will be evaluated as follows (at the first step i = 0):
  1. The "-i" expression is of type unsigned and has the value 0x00000000u.
  2. The variable "one" will be expanded from type "int" to type unsigned and will be equal to 0x00000001u. Note: The type int is expanded (according to the C++ language standard) to type "unsigned" if it participates in an operation where the second argument is of type unsigned.
  3. A subtraction operation occurs, which involves two values ​​of type unsigned, and the result of the operation is 0x00000000u - 0x00000001u = 0xFFFFFFFFu. Note that the result is of unsigned type.
  4. On a 32-bit system, accessing an array at index 0xFFFFFFFFu is equivalent to using index -1. That is, end is analogous to end[-1]. As a result, the array element is processed correctly.
In a 64-bit system in the last paragraph the picture will be different. The unsigned type will be expanded to signed ptrdiff_t and the array index will be equal to 0x00000000FFFFFFFFi64. As a result, the array will be out of bounds. To fix the code, you need to use types such as ptrdiff_t and size_t. There are mistakes for which, in general, no one is to blame, but that does not stop them from being mistakes. Imagine that a long time ago in a distant galaxy (in Visual Studio 6.0) a project was developed that contained the CSampleApp class, which is a descendant of CWinApp. The base class has a virtual function called WinHelp. The heir overrides this function and performs necessary actions. This is visually shown in Figure 7.

Figure 7. Working correct code that was created in Visual Studio 6.0 Then the project is transferred to Visual Studio 2005, where the prototype of the WinHelp function has changed, but no one notices this, since in 32-bit mode the DWORD and DWORD_PTR types are the same and the program continues to work correctly (Figure 8).

Figure 8. Incorrect, but workable 32-bit code The error is waiting to manifest itself on a 64-bit system, where the size of the DWORD and DWORD_PTR types is different (Figure 9). It turns out that in 64-bit mode the classes contain two DIFFERENT WinHelp functions, which is naturally incorrect. Please note that such traps can be hidden not only in MFC, where some functions have changed the types of their arguments, but also in the code of your applications and third-party libraries.

Figure 9. The error manifests itself in 64-bit code. Examples of similar 64-bit errors can be given and given. Those who are interested in such errors and want to learn more about them will be interested in the article “20 pitfalls of porting C++ code to a 64-bit platform.” As you can see, the stage of searching for hidden errors is a non-trivial task, especially since many of them will appear irregularly or only on large input volumes of data. Static code analyzers are well suited for diagnosing such errors, since they can check the entire application code, regardless of the input data and the frequency of execution of its sections in real conditions. It makes sense to use static analysis both at the stage of porting an application to 64-bit platforms in order to find most errors at the very initial stage, and in the further development of 64-bit solutions. Static analysis will warn and teach the programmer to better understand the features of errors associated with the 64-bit architecture and write more efficient code. The author of the article is the developer of one of these specialized code analyzers, called Viva64. You can get acquainted with the tool in more detail and download a demo version from the website of the Software Verification Systems LLC company. To be fair, it should be said that code analyzers such as Gimpel PC-Lint and Parasoft C++Test have sets of rules for diagnosing 64-bit errors. But first of all, these are analyzers general purpose and the rules for diagnosing 64-bit errors are poorly represented in them. Secondly, they are more focused on the LP64 data model used in the Linux operating system family, which reduces their usefulness for windows programs that use the LLP64 data model. The error detection step described in the previous section program code a necessary but not sufficient step. No method, including static code analysis, provides a complete guarantee of detecting all errors, and the best result can only be achieved by combining different techniques.

If your 64-bit program processes more data than the 32-bit version, then you need to expand the tests to include processing of data larger than 4 gigabytes. This is the boundary beyond which many 64-bit errors begin to manifest themselves. Such tests can take an order of magnitude longer and you need to be prepared for this in advance. Typically tests are written in such a way that they process in each test small quantity elements and thereby be able to pass all internal unit tests, for example? in a few minutes, and automated tests (for example, using AutomatedQA TestComplete) in a few hours. A sorting function on a 32-bit system, if it sorts 100 elements, is almost guaranteed to behave correctly on 100,000 elements. But the same function on a 64-bit system can fail when trying to process 5 billion elements. The execution speed of a unit test can decrease by millions of times. Don't forget to factor in the cost of adapting tests when mastering 64-bit systems. One solution is to divide unit tests into fast ones (working with a small amount of memory) and slow ones, processing gigabytes and running, for example, at night. Automated testing of resource-intensive 64-bit programs can be built on the basis of distributed computing.

Over the past few years, many players have often encountered a situation where a newly released toy simply refuses to work on their system. Then, after some research, they realize that the issue is that the game being launched is a 64-bit application.

In this article we in simple language we will tell you why the game you chose did not launch on your computer, why you should switch to a 64-bit operating system and how to launch a 64-bit game.

Why don't 64-bit games run?

Ok, let's start with the simplest thing: 64-bit games require an operating system of the same capacity. Most likely, your computer has a processor with a 64-bit architecture, but the operating system is 32-bit.

A few years ago, developers were still trying to adapt their projects to both 32-bit and 64-bit systems. However, this is currently extremely disadvantageous due to the huge limitations of the 32-bit architecture. In order not to be overloaded with unnecessary information, you, the player, should understand only two things: a 32-bit OS will only support 4 gigabytes of RAM and a 64-bit OS will allow your computer to be more productive.

So let's finally answer the question of why the 64-bit game did not start on your computer. There can be two answers: you have a 32-bit system installed or your processor has a 32-bit architecture, therefore, only supports a 32-bit OS.

How to run 64-bit games?

Is it possible to run a 64-bit game on 32-bit? There can be only one answer: you need a 64-bit operating system (and the same processor). That's all. On the Internet you can find tons of different videos and articles on how to run a 64-bit game on a 32-bit system. But, it must be said right away that the only solution in this situation is to replace the OS.

However, you may have another difficulty: a processor on a 32-bit architecture. Well, in this situation you can only sympathize with you and also ask: where did you dig up such a miracle? Sorry to play everything modern games, you definitely need to get a 64-bit processor and the same operating system - there is no other way.

Yes, some of you may immediately write that running 64-bit applications in a 32-bit environment is possible, for example, using a virtual machine. However, it should be noted that even in this case you will need a processor with 64-bit architecture.

In conclusion

I would like to say that at present there is absolutely no point in running 32-bit operating systems, especially if you are a gamer. If you have a powerful gaming computer, then this bit depth will completely limit the performance of your machine. So there is simply no point in having a 32-bit operating system at the moment.

The emergence of 64-bit Windows raised many questions. Support for 32-bit applications, drivers and everything that is designed for the x86 architecture. Installation and features of using programs. Introduced restrictions for 32-bit applications. Support for old modes and much more. All this could not remain aside. After all, the layer of 32-bit heritage is too large, and in a 64-bit environment there is little that can replace it, even now.

This article provides an overview of the Windows subsystem on Windows 64 (WOW64) and its techniques that allow Windows to support 32-bit applications on a 64-bit system.

Note: The first attempt to introduce 64-bit systems was quite a failure. Strict restrictions and the lack of real advantages made themselves felt. At that time, even drivers for 64-bit systems were quite difficult to find. Not to mention programs in which the difference would be at least somehow noticeable. Removing the 3GB RAM limit is certainly a strong advantage today, but at that time it was more like a beautiful slogan.

Device support for 32-bit applications on 64-bit Windows

Windows 32 to Windows 64 (WOW64)

WOW64 emulates 32-bit Windows

On Windows 64, 32-bit applications run on an emulated 32-bit operating system called Windows 32 on Windows 64, or WOW64 for short. The main task of WOW64 is to intercept and process all system calls from 32-bit applications.

For each intercepted system call, WOW64 creates a 64-bit system call, turning 32-bit data structures into suitable 64-bit ones. Subsequently, the 64-bit system call is passed to the operating system kernel for processing. Any 64-bit call output received will be converted and transmitted in the format that the application intended. In other words, real requests to the system kernel are always 64-bit. The WOW64 subsystem only acts as an intermediary, converting data into suitable formats.

Like 32-bit applications, WOW64 runs as the user, so errors that may occur during system call conversion will occur at the user level. And the 64-bit operating system kernel will not be affected in any way.

The fact that WOW64, like a 32-bit application, runs in user mode explains the reason for the lack of support for 32-bit drivers. In other words, to run correctly, drivers require kernel mode, which WOW64 cannot provide. Therefore, if you have 64-bit Windows, then all drivers must be 64-bit.

The WOW64 emulator consists of the following 64-bit libraries:

Note: These are the only 64-bit libraries that are loaded into a 32-bit process.

  • Wow64.dll is the core infrastructure of the emulation system. Links calls to Ntoskrnl.exe entry points
  • Wow64Win.dll - links calls to Win32k.sys entry points
  • Wow64Cpu.dll - switches the processor between 32-bit and 64-bit mode
  • Ntdll.dll is a 64-bit version of Wow64.

Wow64.dll loads the 32-bit (x86) version of Ntdll.dll and all the necessary 32-bit libraries, which remain largely unchanged. However, some of these 32-bit libraries have been modified to run correctly in WOW64. Typically, such changes were made due to the fact that they share RAM with 64-bit system components

Managing files and registry settings in WOW64

In addition to the functionality of intercepting and processing system calls, the WOW64 interface must also ensure that the files and registry settings of 32-bit applications are stored separately from the files and registry keys of 64-bit programs. To achieve this goal, WOW64 uses two mechanisms. Redirection of files and registry, as well as duplication of registry keys. Redirection maintains a logical view of data and displays it as if the application were running on 32-bit Windows. Duplicating registry keys ensures that changes to a number of parameters that do not depend on bitness will be available to both 32-bit and 64-bit applications.

File redirection

File redirection helps ensure that files and directories of 32- and 64-bit applications are kept separate and do not interfere with each other.

By default, 32-bit application files are installed in:

  • C:\Program Files(x86)

32-bit system files are installed in:

  • C:\WINDOWS\SysWOW64

For 64-bit applications, the files are installed in:

  • C:\Program Files
  • C:\WINDOWS\SYSTEM32

The WOW64 redirection mechanism ensures that requests from 32-bit applications to the "C:\Program Files" and "C:\WINDOWS\SYSTEM32" directories are redirected to the appropriate directories for the 32-bit versions.

However, there is one problem with file redirection. Users and developers should be aware of this feature.

Many 64-bit applications still use 32-bit mode and procedures. And they do not take this into account when creating the installer. To ensure that the application is installed correctly. those. in "C:\Program Files", the installer must make a system call to the operating system so that the system will suspend the Wow64 file redirection mechanism. And after installation, make another system call to enable redirection again. If you install without stopping the redirection, the program will be installed in "C:\Program Files (x86)". A classic example of this bug is the 64-bit version of FireFox 3.5, codenamed "Shiretoko", which is installed in "C:\Program Files(x86)\Shiretoko". Of course, Firefox will still function normally. The only thing you won't be able to do is change the application icon.

Note: This bug may have already been fixed in Shiretoko. However, in earlier versions it was exactly like this.

Registry redirection

Registry keys specific to 32-bit applications will be redirected from the branch:

  • HKEY_LOCAL_MACHINE\Software
  • HKEY_LOCAL_MACHINE\Software\WOW6432Node

Also, sometimes you can find registry entries in another branch (although this is unusual):

  • HKEY_CURRENT_USER\Software\WOW6432Node

This approach allows 32- and 64-bit applications to coexist normally, without problems with overwriting each other’s settings.

Registry duplication

Some redirected registry keys and values ​​need to be duplicated. This means that if a 32-bit application makes changes to a redirected registry key, those changes must also be applied to the 64-bit application branches. In this case, the principle “who is last is right” applies. For example, if you install three applications that associate themselves with the same file extension, then the file extension association should be with the last application.

  1. Install a 32-bit application that associates itself with the XYZ extension
  2. Install a 64-bit version of the application that associates itself with the XYZ file extension
  3. Install another 32-bit application that associates the XYZ extension with itself

As a result of these actions, double click on the file with the XYZ extension, the application that was installed in step 3 should open in Windows Explorer. After all, it was the latter that associated itself with expansion.

All this happens transparently for 32-bit applications in Wow64, which independently intercepts calls and duplicates the necessary parameters and registry keys. In other words, 32-bit applications can be executed in a standard way; the necessary changes will be made for them by Wow64.

There are a number of limitations of the WOW64 subsystem

Some, but not all, 64-bit features are available to 32-bit applications

Wow64 allows 32-bit applications to take advantage of some of the features and capabilities of 64-bit systems. For example, if configured correctly, such applications will be able to use up to 4GB of RAM. Access to other functions is limited due to the design of 64-bit systems. For example, 64-bit Windows OS supports 64-bit logical operations. However, 32-bit applications will not have access to them, they will only be able to use 32-bit logical operations.

Note: The main reason for the limitations is the difference in data presentation between 32- and 64-bit applications. A 32-bit application is simply not designed for 64-bit data types.

You cannot mix code (Code Injection) of 32-bit and 64-bit applications

On a 64-bit Windows OS, you cannot run 32-bit code in a 64-bit process, just as you cannot run 64-bit code in a 32-bit process. Applications that use Code Injection to add functionality to existing applications will typically generate errors.

This fact explains why most 32-bit Windows shell extensions do not run under 64-bit Windows. Most of these extensions use Code Injection to embed themselves in Windows Explorer

WOW64 does not support 16-bit installers

WOW64 provides support for 16-bit Microsoft installers by replacing the installer with a compatible 32-bit version. However, this support does not extend to third party products. So, if you need to use an older program, you will most likely have to look for an emulator or a portable version.


Additional options for running 32-bit applications on Windows 64

Windows Virtual PC

Windows Virtual PC is free software that allows you to run multiple operating systems on one computer. Virtual PC provides a special runtime environment that supports legacy hardware and software that will not be detected and run by Windows 7. All operating systems running under Virtual PC will run in the virtual machine. This means that operating systems that are running will not know that they are running on another system.

System requirements and functionality vary significantly between Virtual PC versions and Windows versions. So, before you try to use Virtual PC, you need to check that the program supports both your operating system and the OS that will be running on it. For example, one of the latest versions no longer supports Windows versions below Windows XP SP3.

Windows XP Mode (XPM)

Windows XP Mode is a specific and stripped-down implementation of Windows Virtual PC that comes pre-installed a copy of Windows XP Professional SP3. This mode is only available in Enterprise, Ultimate and Professional versions of Windows 7 64-bit.

Despite the capabilities this mode should provide, many who have used XPM strongly advise using this mode only as a last resort. Compared to other virtualization products, performance is disappointing and the default configuration raises a number of security issues.

Note: Some more detailed compatibility mode settings can still be accessed. More detailed information you can find in the review How to run old programs on Windows 7/Vista? (See Microsoft Application Compatibility Toolkit).

Multiboot Windows OS

You can install more than one version of Windows on the same computer using a multibooter. For example, install 32-bit and 64-bit versions of Windows next to each other. Each operating system is installed on a separate disk partition, and the boot manager is installed on the default partition. Boot Manager allows you to select and launch the operating system you want to use now.

Although you cannot use more than one operating system at the same time, this functionality is quite useful. Compared to virtual machines, this method does not have any compatibility problems and such systems are much easier to configure and maintain. Among other things, by installing the 32-bit version next to the 64-bit version, you will retain the ability to run 16-bit applications.

To summarize what has been said about 32-bit support on 64-bit Windows

Most 32-bit applications will be quite happy on Windows 64. The main exceptions will be:

  1. 32-bit device drivers
  2. Applications that cannot function without the 32-bit device drivers they use. Antiviruses and other security programs are prime examples.
  3. Extensions that use Code injection. For example, shells for Windows Explorer

Some applications may run with restrictions. This also applies to uninstallers, registry cleaners and tuning programs, since they only have access to that part of the registry that Wow64 shows them.

If you just can’t run a 32-bit application, then consider the option of virtualization or multi-booting multiple operating systems.

Which applications are faster, 32-bit or 64-bit?

This question comes up quite often. But there is no general rule or multiplication factor, since everything depends on the tasks and processor functions used.

When comparing 32-bit and 64-bit applications in their native environments, a 32-bit application typically uses less memory than an equivalent 64-bit application. This is because the 64-bit versions use 64-bit data structures, which take up twice the space. Additional size directly affects the startup and closing times of the program, as well as other types of operations related to accessing disk drives. Typically, this means that 32-bit applications will run faster. However, 64-bit programs' use of the features of a 64-bit processor potentially allows an application to run up to 25% faster than 32-bit programs.

Also, keep in mind that running a 32-bit application on 64-bit Windows means running Wow64, so performance analysis on a 32-bit processor can be set aside. Running Wow64 means not only the cost of converting calls, but also accounting for redirection and duplication mechanisms, which require not only CPU time, but also RAM. So it's possible that a 32-bit application will run faster than a 64-bit one, but it will definitely run slower than an equivalent run on a 32-bit processor.

Rating 5.00 (6 Votes)