MSVCP120.dll and VCRuntime140.dll are Microsoft Visual C++ runtime components used by Windows applications, but they belong to different Visual C++ runtime generations and provide different types of runtime functionality. MSVCP120 is associated with Visual C++ 2013 and provides C++ standard-library functionality, while VCRuntime140 is part of the Visual C++ 2015–2022 runtime family and provides core Visual C++ runtime support.
Although both DLLs can appear in application dependency errors, they are not interchangeable. Understanding their roles can help with software compatibility, runtime installation, and missing-DLL troubleshooting.
MSVCP120 vs VCRuntime140 at a Glance
| Feature | MSVCP120 | VCRuntime140 |
| DLL filename | MSVCP120.dll | VCRuntime140.dll |
| Associated runtime | Visual C++ 2013 | Visual C++ 2015–2022 family |
| Primary role | C++ standard-library runtime | Core Visual C++ runtime |
| Runtime generation | VC++ 2013 | VC++ 2015 and compatible later toolsets |
| Typical software | Older Windows applications and games | Newer Windows applications and games |
| Main functionality | C++ library support | Compiler/runtime support for C and C++ programs |
| Interchangeable | No | No |
| Architecture | x86/x64 depending on application | x86/x64/ARM64 depending on application |
| Can coexist | Yes | Yes |
What Is MSVCP120?
MSVCP120.dll is a component of the Microsoft Visual C++ 2013 runtime environment. It provides Microsoft’s implementation of the C++ standard library for applications compiled with the Visual C++ 2013 toolchain.
Applications can depend on MSVCP120 for standard C++ functionality involving:
- Strings
- Containers
- Streams
- Algorithms
- Iterators
- Memory utilities
- Other C++ standard-library operations
MSVCP120 is therefore primarily concerned with the C++ standard-library layer of an application.
Features of MSVCP120
- Associated with Visual C++ 2013.
- Provides C++ standard-library runtime functionality.
- Supports compatible VC++ 2013 applications.
- Can coexist with other Visual C++ runtime generations.
- May be required by games, desktop applications, utilities, and multimedia software.
Limitations of MSVCP120
- It belongs to an older Visual C++ generation than VCRuntime140.
- It does not provide the same runtime components as VCRuntime140.
- It cannot replace VCRuntime140.dll.
- Applications may require additional Visual C++ runtime libraries.
What Is VCRuntime140?
VCRuntime140.dll is a core Microsoft Visual C++ runtime component associated with the Visual C++ 2015–2022 runtime family.
It provides runtime functionality required by applications compiled using the relevant Visual C++ toolsets. This includes compiler-support functionality and other fundamental runtime services used by C and C++ applications.
VCRuntime140 is different from MSVCP140: the former is primarily the Visual C++ runtime/compiler-support component, while MSVCP140 supplies the C++ standard-library component.
Features of VCRuntime140
- Associated with the Visual C++ 2015–2022 runtime family.
- Provides core C/C++ runtime support.
- Supports applications compiled with compatible Visual C++ toolsets.
- Available through Microsoft Visual C++ Redistributable packages.
- Supports multiple processor architectures through the appropriate runtime packages.
Limitations of VCRuntime140
- It does not replace MSVCP120.dll.
- Applications built against Visual C++ 2013 may still require MSVCP120.
- It may be only one of several runtime DLLs required by an application.
- The appropriate architecture must match the application.
The Main Difference Between MSVCP120 and VCRuntime140
The key differences are runtime generation and functionality.
- MSVCP120 → Visual C++ 2013 + C++ standard library
- VCRuntime140 → Visual C++ 2015–2022 + core Visual C++ runtime
The names themselves provide useful clues. MSVCP120 is associated with Microsoft’s C++ standard-library implementation, whereas VCRuntime140 identifies a core Visual C++ runtime component.
These libraries are designed for different runtime environments and should not be treated as interchangeable DLLs.
MSVCP120 vs VCRuntime140 Compatibility
Compatibility depends on the application and the compiler toolchain used to build it.
MSVCP120 compatibility
MSVCP120 is associated with Visual C++ 2013. Software compiled against that runtime can explicitly depend on MSVCP120.dll.
Installing a later runtime does not automatically remove the application’s dependency on the VC++ 2013 runtime.
VCRuntime140 compatibility
VCRuntime140 belongs to the Visual C++ 2015–2022 runtime family. Compatible applications built with Visual C++ 2015 and later toolsets can depend on this runtime component.
The 2015-and-later Visual C++ runtime family has a different compatibility model from the older VC++ 2013 runtime.
Compatibility considerations
- MSVCP120 and VCRuntime140 belong to different runtime generations.
- Their functions and responsibilities differ.
- Neither DLL is a drop-in replacement for the other.
- Multiple Visual C++ runtime generations can coexist.
- Application architecture affects which redistributable package is required.
- A program can depend on several runtime DLLs simultaneously.
Requirements and Installation
MSVCP120 Requirements
Applications requiring MSVCP120 generally depend on the Visual C++ 2013 Redistributable.
Architecture is important:
- 32-bit application: Usually requires x86 runtime components.
- 64-bit application: Usually requires x64 runtime components.
- 32-bit application on 64-bit Windows: Can still require the x86 package.
VCRuntime140 Requirements
Applications requiring VCRuntime140 generally depend on the Visual C++ 2015–2022 Redistributable or the applicable Microsoft runtime package.
Depending on the application, relevant architectures can include:
- x86
- x64
- ARM64
A 64-bit Windows installation can run 32-bit applications, so installing only the x64 runtime does not necessarily satisfy an x86 application’s dependency.
For security and compatibility, Microsoft Visual C++ Redistributables should be obtained from official Microsoft sources rather than downloading individual DLL files from unofficial websites.
Performance Comparison
MSVCP120 and VCRuntime140 should not be viewed as competing performance libraries.
MSVCP120 primarily supplies C++ standard-library functionality, while VCRuntime140 supplies core compiler/runtime support. Their performance impact depends on how an application uses the respective runtime functions.
Application performance is influenced by factors such as:
- Compiler optimization
- Algorithms and data structures
- CPU architecture
- Memory usage
- File and network I/O
- Third-party libraries
- Application design
- Operating-system configuration
A newer runtime generation does not automatically make an existing application faster simply because its DLL is installed.
Common Use Cases
MSVCP120 Use Cases
MSVCP120 may be encountered in:
- Visual C++ 2013 desktop applications
- PC games built with VC++ 2013
- Multimedia software
- Engineering applications
- Productivity tools
- C++ utilities
VCRuntime140 Use Cases
VCRuntime140 may be encountered in:
- Applications built with Visual C++ 2015 and compatible later toolsets
- Modern Windows desktop software
- PC games
- Multimedia applications
- Development tools
- Productivity and engineering applications
A modern application can also require other runtime components alongside VCRuntime140, depending on how it was compiled.
MSVCP120 Pros and Limitations
Pros
- Provides Microsoft C++ standard-library functionality.
- Supports applications compiled with Visual C++ 2013.
- Can coexist with newer Visual C++ runtimes.
- Provides the runtime component expected by software specifically dependent on MSVCP120.
Limitations
- Cannot replace VCRuntime140.
- Associated with an older runtime generation.
- Does not provide the core runtime functionality represented by VCRuntime140.
- May be only one part of an application’s dependency chain.
VCRuntime140 Pros and Limitations
Pros
- Provides core Visual C++ runtime functionality.
- Supports compatible applications built with the Visual C++ 2015–2022 toolchain family.
- Available for multiple processor architectures.
- Works as part of the broader modern Visual C++ runtime environment.
Limitations
- Cannot replace MSVCP120.
- Does not provide the older VC++ 2013 runtime interface.
- Applications can require additional DLLs, including C++ standard-library components.
- Architecture compatibility still matters.
MSVCP120 vs VCRuntime140 for Missing DLL Errors
The exact DLL mentioned in a Windows error message is an important clue about the missing runtime.
When MSVCP120.dll is missing
A missing MSVCP120.dll error generally indicates that an application expects the Visual C++ 2013 C++ standard-library runtime.
Relevant troubleshooting steps include checking the Visual C++ 2013 Redistributable and matching its architecture to the application.
When VCRuntime140.dll is missing
A missing VCRuntime140.dll error generally indicates that an application expects a compatible Visual C++ 2015–2022 runtime.
Checking, repairing, or reinstalling the applicable Visual C++ Redistributable can restore the required runtime when the application itself is otherwise intact.
A missing VCRuntime140 error can sometimes occur alongside other Visual C++ runtime errors, because applications can depend on multiple DLLs.
Manually renaming one DLL to another or downloading an individual DLL from an unverified website does not establish compatibility.
Can VCRuntime140 Replace MSVCP120?
No.
Although both are Microsoft Visual C++ runtime components, they belong to different runtime generations and provide different functionality.
| DLL | Runtime generation | Primary responsibility |
| MSVCP120.dll | Visual C++ 2013 | C++ standard-library runtime |
| VCRuntime140.dll | Visual C++ 2015–2022 | Core Visual C++ runtime |
An application requiring MSVCP120 may continue to require the Visual C++ 2013 runtime even when VCRuntime140 is installed.
Likewise, VCRuntime140 cannot provide the runtime environment expected by software specifically compiled against MSVCP120.
Troubleshooting MSVCP120 and VCRuntime140 Errors
For MSVCP120 errors
- Identify whether the application is 32-bit or 64-bit.
- Check for the Visual C++ 2013 Redistributable.
- Repair or reinstall the relevant runtime when appropriate.
- Check for other missing VC++ dependencies.
For VCRuntime140 errors
- Determine the application’s architecture.
- Check for the appropriate Visual C++ 2015–2022 Redistributable.
- Repair or reinstall the runtime if necessary.
- Check for related Visual C++ dependencies if the error persists.
For both cases, restoring the appropriate redistributable package is generally more reliable than downloading individual DLL files from third-party sources.
Key Differences Summary
- MSVCP120 is associated with Visual C++ 2013.
- VCRuntime140 belongs to the Visual C++ 2015–2022 runtime family.
- MSVCP120 primarily provides C++ standard-library functionality.
- VCRuntime140 provides core Visual C++ runtime functionality.
- Neither DLL is interchangeable with the other.
- Multiple Visual C++ runtime generations can coexist on Windows.
- Application architecture determines the appropriate runtime package.
- Runtime version alone does not determine application performance.
- Applications can require both runtime families in different software components.
Conclusion
MSVCP120 and VCRuntime140 are both Microsoft Visual C++ runtime components, but they differ in both generation and purpose. MSVCP120 is associated with Visual C++ 2013 and provides C++ standard-library functionality, while VCRuntime140 is part of the Visual C++ 2015–2022 runtime family and provides core C/C++ runtime support.
Neither DLL is a direct replacement for the other. An application built against Visual C++ 2013 may specifically require MSVCP120, while software built with a compatible Visual C++ 2015-or-later toolchain may depend on VCRuntime140.
For compatibility and troubleshooting, the exact DLL named by the application, its compiler/runtime dependencies, and its processor architecture are the most useful factors. MSVCP120 and VCRuntime140 should therefore be understood as distinct runtime components with different roles rather than interchangeable options.