You double-click a .DLL file and Windows asks “How do you want to open this file?”, or an app refuses to start with “The program can’t start because MSVCP140.dll is missing from your computer.” A DLL isn’t something you open directly, because other programs load it. You can still look inside one safely, and you can fix “missing DLL” errors without touching system files.
How to Open a DLL File: The Quick Answer
You don’t run or open a DLL the way you open a document or an .exe. To see what’s inside, open a copy of it in an inspection tool. Use File Explorer’s Properties dialog, Dependencies, Resource Hacker, or dumpbin for native Windows DLLs, and use ILSpy or dotPeek for .NET DLLs.
If you’re here because of a “missing DLL” error, skip inspection and repair the component that owns the file with sfc /scannow, DISM, or the official Microsoft Visual C++ Redistributable.
| Goal | Tool | Install needed? | Works on |
|---|---|---|---|
| Check version, publisher, signature | File Explorer Properties | No | Any DLL |
| See which DLLs it depends on | Dependencies | Yes (free, open source) | Native DLLs |
| Browse icons, version info, strings | Resource Hacker | Yes (check license at download) | Native DLLs |
| List exported functions and headers | dumpbin | Visual Studio or Build Tools | Native DLLs |
| Read decompiled C# or IL code | ILSpy or dotPeek | Yes (free) | .NET DLLs |
| Fix a missing or corrupted system DLL | sfc /scannow, DISM | No | Windows system files |
Fix missing MSVCP###.dll / VCRUNTIME###.dll | Visual C++ Redistributable | Yes (Microsoft download) | Apps built with Visual C++ |
What Is a DLL File?
A DLL (Dynamic Link Library) is a container of code and resources that programs share. Windows itself, games, and Office all load DLLs at runtime to borrow functions, icons, or dialog layouts. A DLL may have an optional initialization routine that runs when a program loads it, but it has no normal launch point for you as a user, so double-clicking one usually just brings up an “open with” prompt or an error.
DLLs come in two broad types:
- Native DLLs contain compiled machine code for x86, x64, or ARM64. You can list what they contain, and reverse-engineering tools can disassemble them into approximate pseudocode, but the original source code, names, and comments are generally gone.
- .NET assembly DLLs contain Intermediate Language (IL). A decompiler can turn IL back into fairly readable C#.
Never edit or overwrite a system DLL. Changing a file invalidates an embedded digital signature, and many Windows files are verified through catalog signatures that the modified file no longer matches. Depending on the file and the app, the result can range from no visible effect to crashes, repair prompts, or security warnings.
Before You Begin
- A Windows 10 or Windows 11 PC
- An administrator account (required for
sfcand DISM) - An internet connection to download the inspection tools you want
- Visual Studio or Build Tools for Visual Studio, but only if you want
dumpbin - A recent backup to an external hard drive or cloud storage before running any repair commands
| Requirement | Details |
|---|---|
| OS version | Windows 10 or Windows 11 |
| Admin rights | Needed for sfc /scannow and DISM |
| dumpbin | Ships with Visual Studio / Build Tools, not sold separately |
| Cost | Properties, sfc, DISM, Dependencies, and ILSpy cost nothing; Visual Studio/Build Tools, dotPeek, and Resource Hacker have their own license terms, so check them when you download |
Step-by-Step Guide: Inspect a DLL Without Touching the Original
Safety Check Before You Begin
Copying a DLL to a new folder does not make it safe to inspect. Checking its Properties (Step 2) only reads metadata, but Dependencies, Resource Hacker, dumpbin, and decompilers parse the whole file, so a malformed or malicious DLL can still target them. Before you open an unfamiliar or suspicious file, scan it with Microsoft Defender or another trusted antivirus tool, and don’t run, register, or double-click it to “test” it.
If the file came from an untrusted source or you still have doubts after scanning, do every step below inside Windows Sandbox (Windows 10/11 Pro, Enterprise, and Education) or a disposable virtual machine, or submit it to a reputable online analysis service instead of opening it on your main PC. Keep confidential or proprietary binaries off public scanning services, since many of them share submitted samples publicly.
Step 1: Make a Safe Copy of the DLL
- Open File Explorer and go to the folder that contains the DLL.
- Right-click the DLL and select Copy.
- Go to
Documents, create a new folder namedDLL inspection, and paste the file there.
Expected result: You now work only on the copy. The original in C:\Windows\System32 or in the app folder stays untouched.
Working on a copy protects the original from accidental changes, but it doesn’t make a suspicious file safe to open. If you haven’t already scanned the file as described above, do that before continuing.
Tip: If Windows says the file is in use, close the app that uses it or restart your PC. Don’t force-close unrelated system processes to unlock it.
Step 2: Check the File’s Properties
- Right-click the copied DLL and choose Properties.
- On the General tab, confirm the file type and size.
- Open the Details tab and check File version, Product name, and Copyright.
- Open the Digital Signatures tab, if it’s present, and check who signed the file.
Expected result: A legitimate Microsoft or vendor DLL usually shows a matching company name and a signature. An unsigned DLL deserves caution, but it isn’t automatically malware. Some genuine Windows files are catalog-signed and don’t show this tab at all.
Step 3: View Dependencies with the Dependencies App
- Download Dependencies from its official open-source project page and extract the ZIP.
- Run
DependenciesGui.exe. - Click File > Open and select your copied DLL.
- Expand the tree in the left pane to see every DLL that your file imports.
Expected result: You see a tree of imported modules, with missing or architecture-mismatched entries flagged. A flag is a lead, not proof: API sets, delay-loaded modules, and optional imports can show as missing even on a healthy PC, so focus on non-Windows DLLs that also appear in the app’s error message.
Note: Entries that start with
api-ms-win-are internal Windows API sets, not real files. Don’t try to download them.
Step 4: Browse Resources with Resource Hacker
- Download Resource Hacker from the developer’s official site and install it.
- Launch it and click File > Open.
- Select your copied DLL.
- Expand Version Info, Icon, or String Table in the left pane.
Expected result: You can read embedded version info, manifests, dialogs, and strings. Resource Hacker can also edit resources, so view only and never save changes over a real system file.
Step 5: List Exports and Headers with dumpbin
- Install Visual Studio or Build Tools for Visual Studio and select the C++ build tools so the MSVC tools (including
dumpbin) are installed. - Click Start, type Developer Command Prompt, and open it.
- Run these commands, replacing
example.dllwith your file name:
cd /d "%USERPROFILE%\Documents\DLL inspection"
dumpbin /exports example.dll
dumpbin /headers example.dllExpected result: /exports lists the functions the DLL exposes to other programs. In /headers, the machine line shows whether the file is x86, x64, or ARM64. A listed export isn’t necessarily safe or meant for you to call directly.
Tip: Run
dumpbin /clrheader example.dllto check whether the file is a .NET assembly. If it shows a CLR header, go to Step 6.
Step 6: Decompile a .NET DLL with ILSpy (or dotPeek)
- Download the latest ILSpy build from the official ILSpy GitHub releases page and extract it.
- Launch ILSpy and click File > Open.
- Select your copied .NET DLL.
- Expand the assembly in the left pane and click a class or method.
- Use the language drop-down in the toolbar to switch between C# and IL.
Expected result: You see readable classes and methods. ILSpy reads code without running it, but it still has to parse the file, so open an unfamiliar or suspicious assembly only inside Windows Sandbox or a disposable virtual machine.
Decompilers can still choke on malformed or deliberately adversarial files, and decompiled output can contain code that’s dangerous if you build or run it. Treat ILSpy and dotPeek as read-only: view the code, and don’t compile or execute anything they produce.
Prefer JetBrains? Install dotPeek from JetBrains’ website, then use File > Open to load the copied DLL the same way. Check JetBrains’ current license terms when you download it.
Fixing a Missing DLL Error the Safe Way
Errors like “MSVCP140.dll is missing” tempt you to grab a single DLL from a download site. Don’t. Loose DLLs from those sites can be the wrong architecture, out of date, tampered with, or outright malware. Repair the component that owns the file instead, starting with the least invasive fix.
Fix #1: Install the Official Visual C++ Redistributable
Use this fix when the error names MSVCP###.dll, VCRUNTIME###.dll, or a similar Visual C++ runtime file.
- Go to Microsoft’s latest supported Visual C++ downloads page.
- Download the package that matches the app:
vc_redist.x64.exe,vc_redist.x86.exe, orvc_redist.arm64.exe. A 32-bit app on 64-bit Windows needs the x86 package, and some setups need both x86 and x64 installed side by side. Older apps may also need an older runtime generation, such as Visual C++ 2010 or 2013, which the latest package doesn’t replace. On an ARM64 PC, Microsoft’s current x64 package also contains the ARM64 binaries and installs them where needed, so check the download page before picking a package. - Run the installer, accept the license terms, and click Install. If it’s already installed, choose Repair.
- Restart the affected app.
The list of Visual Studio versions each package covers changes over time, so confirm it on the download page. Microsoft’s Redistributing Visual C++ files guide explains why the redistributable is the supported way to deliver these DLLs.
Fix #2: Run System File Checker
Use this fix when a Windows system DLL appears missing or corrupted, especially after an update or a crash.
SFC repairs protected Windows components it finds damaged, provided a clean source file is available; it doesn’t fix third-party application DLLs or guarantee every change gets reversed. SFC on its own is a quick first check, but Microsoft’s full repair sequence runs DISM (Fix #3) first, because DISM restores the source files SFC repairs from, and then runs SFC again.
- Click Start and type cmd.
- Right-click Command Prompt and select Run as administrator.
- Run this command:
sfc /scannow- Wait for the scan to reach 100%. Restart Windows if it reports that it repaired files.
Fix #3: Repair the Component Store with DISM
Use DISM for a full repair, and always when SFC reports that it couldn’t fix some files. DISM repairs the Windows image that SFC pulls clean copies from, but like SFC it can only restore components it manages, not third-party application files.
- Open Command Prompt as administrator.
- Run these commands one at a time:
DISM /Online /Cleanup-Image /CheckHealth
DISM /Online /Cleanup-Image /ScanHealth
DISM /Online /Cleanup-Image /RestoreHealth- Run
sfc /scannowagain. - Restart your PC.
If the error is “Entry point not found,” reinstall or repair the app that shows it rather than copying a different DLL version over the existing one.
Configuration: What the Key Readouts Mean
| Setting / Output | What it tells you |
|---|---|
| Digital Signatures tab | Whether the file is signed and by whom. Unsigned files deserve caution but aren’t proof of malware. |
dumpbin /exports | Functions the DLL exposes to other programs |
dumpbin /headers | PE header details, including the target architecture (x86/x64/ARM64) |
| Dependencies architecture | Confirms the DLL’s architecture matches the app that loads it |
Tips and Troubleshooting
“The DLL is not a valid Win32 application.” This usually means a 32-bit/64-bit mismatch or a file that isn’t a real Windows DLL. Check the architecture with dumpbin /headers or Dependencies. If the error appears when you launch an app, see how to fix “This app can’t run on your PC” errors.
ILSpy shows garbage or nothing useful. The DLL is probably native, or it’s obfuscated. Confirm it’s a .NET assembly first. For native files, switch to dumpbin, Dependencies, or Resource Hacker.
Dependencies flags api-ms-win-* DLLs as missing. These are Windows loader contracts. If the app runs, ignore them and focus on missing third-party DLLs.
You found an unfamiliar DLL and don’t trust it. Inspect the signature in Properties first, and scan it with Microsoft Defender or another trusted antivirus tool before opening it in any other tool.
If it still looks suspicious after scanning, open it only on a disposable VM or submit it to a reputable online analysis service rather than your main PC, and keep confidential files off public scanners.
Editing a system DLL broke something. Try Fix #2 and Fix #3. SFC and DISM can repair protected Windows components when they detect corruption and have a clean source to restore from, but they won’t necessarily reverse every change or fix files they don’t manage.
For a third-party DLL, repair or reinstall the app that owns it instead. If repairs don’t resolve the problem, restore from a recent backup or use Windows recovery options.
Wrapping Up
Many “missing DLL” errors are solved by the official Visual C++ Redistributable (Fix #1), and DISM plus SFC cover damaged Windows files. If neither helps, repair or reinstall the app that shows the error, since it may need a different runtime or a third-party DLL it ships with.
For simple curiosity, Properties plus Dependencies covers most needs without any developer tools. If SFC and DISM keep finding new corruption after every restart, the cause is usually bigger than a single bad DLL. Run a full Microsoft Defender scan, check the drive with chkdsk and its SMART health status, and test memory with Windows Memory Diagnostic before replacing any hardware.
| Step | Action | Applies To |
|---|---|---|
| 1–2 | Copy the file, check Properties | Any DLL |
| 3–5 | Dependencies, Resource Hacker, dumpbin | Native DLLs |
| 6 | ILSpy or dotPeek | .NET DLLs |
| Fix #1 | Visual C++ Redistributable | MSVCP/VCRUNTIME errors |
| Fix #2–3 | sfc /scannow, DISM | Windows system DLLs |