The default go-to tool for most .Net developers is NuGet. It simplifies handling dependencies across projects and also provides a central reference point for reusable .Net components. Due to its initial development and growth over time, NuGet poses a few shortcomings evident over the years. As an alternative, specifically for F# developers, Paket is an open source dependency manager for .Net projects that was originally built with the primary goal of addressing some of the shortcomings developers encountered when managing dependencies in large and complex projects.

Paket is flexible, powerful and backward-compatible with the NuGet service. This enables developers to continue using already existing NuGet packages on transitioning. With features like transitive dependency handling, tighter version control and centralized dependency definitions, Paket is especially useful for enterprise-scale F# applications that rely on multiple libraries or even different frameworks.


Some challenges with the NuGet client

Invalid references across projects — Accidentally adding different versions of the same NuGet package to different projects in the same solution (For example, Project A might use Newtonsoft.Json version 6, while Project B uses version 7.) won’t cause a compile error, but it could lead to runtime issues, depending on various factors.

NuGet pdates project file on upgrade — Updating a NuGet dependency will change the project file, as the version number is part of the file path. This can lead to merge conflicts and unnecessary changes in the project file during version updates.

Difficulty managing complex solutions — Managing NuGet in large solutions or across multiple projects can be tricky because it doesn’t provide a unified view of all dependencies. While NuGet 3 improved the experience a bit, it’s still common to avoid upgrading packages for fear of breaking something in the solution.

In-Script referencing — Referencing NuGet packages from scripts can be challenging since the package path is stored in the project. If a package is updated, your scripts might break unless you’re using a tool like VFPT’s generated references file to manage it.


Key Advantages of Paket

Paket solves all of the previously mentioned issues and introduces several new features, such as:

  1. Centralized dependency management — NuGet handles dependencies at the project level such that, each project has its own packages.config file or *.csproj references, making it harder to manage consistency across multiple projects in the same solution. With Paket, dependencies are centralized using a single paket.dependencies file for the entire solution, making it easier to manage versions and dependencies from one location.

    With the centralized approach, you can easily upgrade or downgrade libraries across projects while ensuring that all projects stay in sync. This separation also makes it easier for source control systems like Git to manage changes in dependencies since it’s all controlled from a few centralized files.

  2. Dependency Resolver — Paket manages transitive dependencies dependencies across all projects in your solution or repository, ensuring consistency. It won’t let you accidentally upgrade a dependency in just one part of your solution, keeping everything stable across projects.

    Child dependencies within projects are also handled in a way that lets you focus on managing the top-level dependencies, while it automatically handles the child dependencies behind the scenes. For example, you can specify exact versions, pin certain libraries to avoid upgrades, or use floating versions to always get the latest stable release. This level of control is harder to achieve with NuGet alone.

    Paket is very fast, thanks to its smart resolver and caching system, ensuring that package restores happen as quickly as possible.

  3. Support for Multi-Targeting Frameworks — When building libraries or applications that need to support multiple versions of .NET (e.g., .NET Framework, .NET Core), Paket simplifies dependency management across these frameworks. You can define separate dependency groups for different target frameworks in your paket.dependencies file and have more flexibility when supporting a wide range of runtime environments.

  4. Lightweight — Paket is lightweight and command-line focused. While it has a Visual Studio extension, it’s mainly a wrapper around the command-line tool. You can add packages without a GUI, using simple, plain text configuration files that are easy to manage.

  5. Source code dependencies — When working with small dependencies such as helper or utility modules that don’t need a full NuGet package, Paket enables dependency on specific versions of source code, like a particular commit from a GitHub file.

Paket has several benefits, particularly for F#. It simplifies dependency management in scripts and doesn’t lock you into Visual Studio, allowing you to use other IDEs like Visual Studio Code.


Here are some common Paket commands:

-paket update: Updates your packages to the latest versions from NuGet. Paket selects the highest compatible version and ensures that all dependencies work together.
-paket restore: Downloads the current versions of all dependencies specified in the lock file, ensuring repeatable builds—especially useful for CI processes.
-paket add: Adds a new NuGet package to your dependencies. For example, paket add nuget Automapper project NugetFSharp fetches the latest version of Automapper and adds it to the NugetFSharp project.
-paket generate-load-scripts: Creates .fsx files that automatically reference assemblies in a package and its dependencies.

Paket also has a Visual Studio extension that integrates this functionality directly into the IDE.


Using Paket in F# Projects

Let’s walk through a basic example of how to set up Paket in an F# project.

1. Install Paket
To start using Paket, the first step is to install it in your project or solution. You can do this by running:

dotnet tool install paket --global

Or, if you prefer to install it locally in the project directory:

dotnet new tool-manifest
dotnet tool install paket

2. Convert Existing Projects from NuGet to Paket
If you’re already using NuGet, Paket provides an easy way to migrate your project. You can convert the existing packages.config or *.csproj files to Paket with:

paket convert-from-nuget

This command will automatically generate the necessary Paket files (paket.dependencies, paket.lock, and paket.references) and move the dependency management logic from your project files to Paket’s files.

3. Manage Dependencies with Paket
Once you’ve set up Paket, the next step is to add and manage dependencies. You’ll work with the following files:

  • paket.dependencies: Defines the overall dependencies for the solution.
  • paket.lock: Locks the dependency versions to ensure reproducibility across builds.
  • paket.references: Specifies which dependencies should be referenced in each project.

For example, to add a new dependency, such as FSharp.Core, open the paket.dependencies file and add:

nuget FSharp.Core

Then, run:

paket install

This will download the package and update the references across your projects.

4. Multi-Targeting Frameworks
To support multiple frameworks, you can define groups in the paket.dependencies file:

framework: netcoreapp3.1
nuget FSharp.Core

group NetFramework
framework: net472
nuget FSharp.Core

This setup ensures that your solution correctly manages dependencies across different frameworks.


Paket vs. NuGet: When to Use Which?

Both Paket and NuGet have their strengths, and the choice depends on your project needs.

  • Use Paket if:

    • You’re managing a large solution with multiple projects that require consistent dependency versions.
    • You need more control over transitive dependencies and want a clear, centralized way of managing them.
    • You’re working with multi-targeted projects and need flexible framework support.

  • Stick with NuGet if:

    • You’re working on smaller projects where NuGet’s simplicity suffices.
    • You prefer tight Visual Studio integration with minimal setup.

Although NuGet is the default package manager in the .NET ecosystem, Paket provides F# developers with more flexibility, improved dependency control, and better project management features. For complex F# projects with multiple libraries, transitive dependencies, or different target frameworks, Paket simplifies dependency management, reduces conflicts, and streamlines the development process.

Switching to Paket gives you centralized control over your dependencies, better versioning management, and cleaner, simpler project files — making it a valuable tool for professional and enterprise-level F# development.