Should NuGet packages be in source control?

How to enable NuGet source?

I've searched high and low but can't find a reference to .

I don't know what I am doing wrong but I want to use the NuGet packages source on my project instead of the default C:UsersAppDataLocalNuget uget.config file.

I've checked out the docs for NuGet and it doesn't mention anything about an nuget. What am I doing wrong? You do this by editing your nuget.config or global.json (for windows users) - see
To get at these files just right click on your solution in the solution explorer, or your individual projects/solution if you are working from command line, and pick Open in Explorer. Alternatively, have a look here for some good starting docs. Open the solution file . Then go to the MSBuild Tab and check Enable NuGet Package Restore.

How do I fix a missing NuGet package?

I try to install some new NuGet package but it throws an error: "Could not install package 'Todo.

Async.Net.Sockets'. Then I find the .Net version has changed so it is now net46. But when I again build my project using VS2015 to make sure it didn't change, it tells me that the TargetFrameworkVersion hasn't changed. So I'm not sure what the problem is. Could someone help? Thanks.

Finally found it: The Todo.Sockets had a reference to the Microsoft.Windows.Compatibility library. If you're interested in this particular NuGet package, go to and see where they have put the assembly in their sources.

Should NuGet packages be in source control?

We have a few dozen NuGet packages for our ASP.

NET MVC applications that all do "magic" things in our application. They also do other things which should be out of sight from the client, but should be in source control. The packages are written by a 3rd party company, which provides them as an MSIL package (.dlls), and the packages are added as References to my apps, in the project. I don't see why we shouldn't put them in source control.

So my question is, do NuGet packages belong in source control? Am I missing a reason why they should not be there? How do other large scale developers handle these types of packages in their solutions? 7 Answers.
We do have them under source control; specifically they're in version control through TeamCity. But that's mainly because everything else (except perhaps the binaries themselves) goes in the repository too; the fact is that they're more often than not shared assets, because: Their purpose is to add functionality to your solution. If the dependency/additional functionality is also going to be used in other projects, putting it in the repository also lets you share it. Having said that, it's really better not to treat all the dlls of a project like this, but only ones that get into source control; for example, when working with a third-party, the binaries would typically be versioned independently of the codebase, to avoid them getting overwritten when you do a release or a build of the application. You certainly can store the .nuspec files if you want to, but it's far better to just make this choice based on whether they're part of your source control strategy (which we now include within our Git deployment scripts). That keeps them out of the repository until they actually come into use by your CI server. Of course, you can still add new NuGet packages manually, and it would not hurt them to be in the repository and available as references; however, you might have reasons to make this process unnecessary once CI starts managing them.

When it comes to projects that have a lot of NuGet packages already, it's generally sufficient to get your projects configured correctly so that NuGet manages the packages and adds them to any .csproj's that aren't configured manually.

What is NuGet package source mapping?

In this post, we'll look at what package source mapping is, why you might want it and how to enable it.

We'll also look at how package source mapping works and the performance implications of having it enabled.

A package is an assembly or binary with a .nupkg file extension. In fact, NuGet was originally named the .NET Nupkg Package Format back in 2025 when NuGet first shipped. You can learn more about the history of NuGet and the .nupkg format in the article, Building the Perfect NuGet Package.

When you first build your project, NuGet copies the packages to be used into your project's output folder and creates a .nupkg file for each one. Each package has a name and version that NuGet will use to reference the package, and it also has a version number that NuGet will use for package dependencies.

This version number isn't stored in the .nupkg file itself, however. Instead, it is stored in a metadata file that is saved in the packages directory. This metadata file contains the information needed for NuGet to properly resolve package dependencies. This is referred to as the NuGet package source.

This metadata file is responsible for NuGet resolving package dependencies and is written in XML. For our packages, the metadata file is called .nuspec.

If your project has multiple packages, you can add more packages in the same folder in the same project. NuGet also allows you to create a new project and copy packages from one project to another, which will create a package reference and package dependencies that NuGet will use.

Package source mapping. The .nuspec file is what tells NuGet what package dependencies are available, and where those packages are in your project. In addition, it is the file that NuGet uses to locate the files that make up the package. The .nuspec file is written in XML, which means it is human readable and editable. If your project's packages change over time, it's easy to update .nuspec files without overwriting them. However, the problem with human-editable files is that they can get out of sync with each other. They can become corrupted or otherwise not match their dependencies.

To address this problem, NuGet has a special feature where it will create a cached copy of a package's .