Notices: This section not yet converted to new layout. Download stats are rolling back out.




Downloads of v 0.9.9-beta2-20150202


Last update

This is a prerelease version of Chocolatey.



There are no package test results for this package

This package was approved as a trusted package on 2/2/2015.

Chocolatey is a package manager for Windows (like apt-get but for Windows). It was designed to be a decentralized framework for quickly installing applications and tools that you need. It is built on the NuGet infrastructure currently using PowerShell as its focus for delivering packages from the distros to your door, err computer.

Chocolatey is brought to you by the work and inspiration of the community, the work and thankless nights of the Chocolatey Team, with Rob heading up the direction.

You can host your own sources and add them to Chocolatey, you can extend Chocolatey's capabilities, and folks, it's only going to get better.


There are quite a few commands you can call - you should check out the command reference. Here are the most common:

  • Search - choco search something
  • List - choco list -lo
  • Install - choco install baretail
  • Pin - choco pin windirstat
  • Upgrade - choco upgrade baretail
  • Uninstall - choco uninstall baretail

    Alternative installation sources (TEMPORARILY DISABLED IN 0.9.9):

  • Install ruby gem - choco install compass -source ruby
  • Install python egg - choco install sphynx -source python
  • Install windows feature - choco install IIS -source windowsfeatures
  • Install webpi feature - choco install IIS7.5Express -source webpi

For more advanced commands and switches, use choco -? or choco command -h. You can also look at the command reference, including how you can force a package to install the x86 version of a package.

Create Packages?

We have some great guidance on how to do that. Where? I'll give you a hint, it rhymes with sticky! Wiki!

In that mess there is a link to the Helper Reference.

To install Chocolatey, run the following command from the command line or from PowerShell:

C:\> choco install chocolatey --version 0.9.9-beta2-20150202 --pre

To upgrade Chocolatey, run the following command from the command line or from PowerShell:

C:\> choco upgrade chocolatey --version 0.9.9-beta2-20150202 --pre


  • tools\chocolateyInstall.ps1 Show
    $toolsPath = (Split-Path -parent $MyInvocation.MyCommand.Definition)
    # ensure module loading preference is on
    $PSModuleAutoLoadingPreference = "All";
    $modules = Get-ChildItem $toolsPath -Filter *.psm1
    $modules | ForEach-Object {
    														$psm1File = $_.FullName;
    														$moduleName = $([System.IO.Path]::GetFileNameWithoutExtension($psm1File))
    														remove-module $moduleName -ErrorAction SilentlyContinue;
    														import-module -name  $psm1File;
  • tools\chocolateyInstall\choco.exe
  • tools\chocolateyInstall\choco.exe.ignore
  • tools\chocolateysetup.psm1 Show
    $thisScriptFolder = (Split-Path -parent $MyInvocation.MyCommand.Definition)
    $chocInstallVariableName = "ChocolateyInstall"
    $sysDrive = $env:SystemDrive
    $tempDir = $env:TEMP
    $defaultChocolateyPathOld = "$sysDrive\Chocolatey"
    $ErrorActionPreference = 'Stop'
    function Initialize-Chocolatey {
        This will initialize the Chocolatey tool by
          a) setting up the "nugetPath" (the location where all chocolatey nuget packages will be installed)
          b) Installs chocolatey into the "nugetPath"
                c) Instals .net 4.0 if needed
          d) Adds chocolaty to the PATH environment variable so you have access to the chocolatey|cinst commands.
      .PARAMETER  NuGetPath
        Allows you to override the default path of (C:\Chocolatey\) by specifying a directory chocolaty will install nuget packages.
        C:\PS> Initialize-Chocolatey
        Installs chocolatey into the default C:\Chocolatey\ directory.
        C:\PS> Initialize-Chocolatey -nugetPath "D:\ChocolateyInstalledNuGets\"
        Installs chocolatey into the custom directory D:\ChocolateyInstalledNuGets\
      [Parameter(Mandatory=$false)][string]$chocolateyPath = ''
      $chocoNew = $installModule = Join-Path $thisScriptFolder 'chocolateyInstall\choco.exe'
      & $chocoNew unpackself --force
      $installModule = Join-Path $thisScriptFolder 'chocolateyInstall\helpers\chocolateyInstaller.psm1'
      Import-Module $installModule -Force
      if ($chocolateyPath -eq '') {
        $programData = [Environment]::GetFolderPath("CommonApplicationData")
        $chocolateyPath = Join-Path "$programData" 'chocolatey'
      # variable to allow insecure directory:
      $allowInsecureRootInstall = $false
      if ($env:ChocolateyAllowInsecureRootDirectory -eq 'true') { $allowInsecureRootInstall = $true }
      # if we have an already environment variable path, use it.
      $alreadyInitializedNugetPath = Get-ChocolateyInstallFolder
      if ($alreadyInitializedNugetPath -and $alreadyInitializedNugetPath -ne $chocolateyPath -and ($allowInsecureRootInstall -or $alreadyInitializedNugetPath -ne $defaultChocolateyPathOld)){
        $chocolateyPath = $alreadyInitializedNugetPath
      else {
        Set-ChocolateyInstallFolder $chocolateyPath
      Create-DirectoryIfNotExists $chocolateyPath
      #set up variables to add
      $chocolateyExePath = Join-Path $chocolateyPath 'bin'
      $chocolateyLibPath = Join-Path $chocolateyPath 'lib'
      if ($tempDir -eq $null) {
        $tempDir = Join-Path $chocolateyPath 'temp'
        Create-DirectoryIfNotExists $tempDir
      $yourPkgPath = [System.IO.Path]::Combine($chocolateyLibPath,"yourPackageName")
    We are setting up the Chocolatey package repository.
    The packages themselves go to `'$chocolateyLibPath`'
      (i.e. $yourPkgPath).
    A shim file for the command line goes to `'$chocolateyExePath`'
      and points to an executable in `'$yourPkgPath`'.
    Creating Chocolatey folders if they do not already exist.
    "@ | Write-Output
      Write-Warning "You can safely ignore errors related to missing log files when `n  upgrading from a version of Chocolatey less than 0.9.9. `n  'Batch file could not be found' is also safe to ignore. `n  'The system cannot find the file specified' - also safe."
      #create the base structure if it doesn't exist
      Create-DirectoryIfNotExists $chocolateyExePath
      Create-DirectoryIfNotExists $chocolateyLibPath
      Install-ChocolateyFiles $chocolateyPath
      Ensure-ChocolateyLibFiles $chocolateyLibPath
      Install-ChocolateyBinFiles $chocolateyPath $chocolateyExePath
      $chocolateyExePathVariable = $chocolateyExePath.ToLower().Replace($chocolateyPath.ToLower(), "%DIR%..\").Replace("\\","\")
      Initialize-ChocolateyPath $chocolateyExePath $chocolateyExePathVariable
      Process-ChocolateyBinFiles $chocolateyExePath $chocolateyExePathVariable
      $realModule = Join-Path $chocolateyPath "helpers\chocolateyInstaller.psm1"
      Import-Module "$realModule" -Force
      if (-not $allowInsecureRootInstall) {
        Upgrade-OldChocolateyInstall $defaultChocolateyPathOld $chocolateyPath
        Install-ChocolateyBinFiles $chocolateyPath $chocolateyExePath
    Chocolatey (choco.exe) is now ready.
    You can call choco from anywhere, command line or powershell by typing choco.
    Run choco /? for a list of functions.
    You may need to shut down and restart powershell and/or consoles
     first prior to using choco.
    "@ | write-Output
    function Set-ChocolateyInstallFolder {
      $environmentTarget = [System.EnvironmentVariableTarget]::User
      Install-ChocolateyEnvironmentVariable -variableName "$chocInstallVariableName" -variableValue $null -variableType $environmentTarget
      if (Test-ProcessAdminRights) {
        Write-Debug "Administrator installing so using Machine environment variable target instead of User."
        $environmentTarget = [System.EnvironmentVariableTarget]::Machine
        Install-ChocolateyEnvironmentVariable -variableName "$chocInstallVariableName" -variableValue $null -variableType $environmentTarget
      Write-Output "Creating $chocInstallVariableName as an environment variable (targeting `'$environmentTarget`') `n  Setting $chocInstallVariableName to `'$folder`'"
      Write-Warning "It's very likely you will need to close and reopen your shell `n  before you can use choco."
      Install-ChocolateyEnvironmentVariable -variableName "$chocInstallVariableName" -variableValue "$folder" -variableType $environmentTarget
    function Get-ChocolateyInstallFolder(){
    function Create-DirectoryIfNotExists($folderName){
      if (![System.IO.Directory]::Exists($folderName)) { [System.IO.Directory]::CreateDirectory($folderName) | Out-Null }
    function Upgrade-OldChocolateyInstall {
      [string]$chocolateyPathOld = "$sysDrive\Chocolatey",
      [string]$chocolateyPath =  "$($env:ALLUSERSPROFILE)\chocolatey"
      if (Test-Path $chocolateyPathOld) {
        Write-Output "Attempting to upgrade `'$chocolateyPathOld`' to `'$chocolateyPath`'."
        Write-Warning "Copying the contents of `'$chocolateyPathOld`' to `'$chocolateyPath`'. `n This step may fail if you have anything in this folder running or locked."
        Write-Output 'If it fails, just manually copy the rest of the items out and then delete the folder.'
        Write-Warning "!!!! ATTN: YOU WILL NEED TO CLOSE AND REOPEN YOUR SHELL !!!!"
        $chocolateyExePathOld = Join-Path $chocolateyPathOld 'bin'
        'Machine', 'User' |
        % {
          $path = Get-EnvironmentVariable -Name 'PATH' -Scope $_
          $updatedPath = [System.Text.RegularExpressions.Regex]::Replace($path,[System.Text.RegularExpressions.Regex]::Escape($chocolateyExePathOld) + '(?>;)?', '', [System.Text.RegularExpressions.RegexOptions]::IgnoreCase)
          if ($updatedPath -ne $path) {
            Write-Output "Updating `'$_`' PATH to reflect removal of '$chocolateyPathOld'."
            Set-EnvironmentVariable -Name 'Path' -Value $updatedPath -Scope $_
        Copy-Item "$chocolateyPathOld\bin\*" "$chocolateyPath\bin" -force -recurse
        Copy-Item "$chocolateyPathOld\lib\*" "$chocolateyPath\lib" -force -recurse
        try {
          Write-Output "Attempting to remove `'$chocolateyPathOld`'. This may fail if something in the folder is being used or locked."
          Remove-Item "$($chocolateyPathOld)" -force -recurse
        catch {
          Write-Warning "Was not able to remove `'$chocolateyPathOld`'. You will need to manually remove it."
    function Install-ChocolateyFiles {
      "$chocolateyPath\chocolateyInstall", "$chocolateyPath\helpers", "$chocolateyPath\redirects", "$chocolateyPath\tools" | % {
        if (Test-Path $_) {
          Remove-Item $_ -exclude *.log -recurse -force
      # rename the currently running process / it will be locked if it exists
      $chocoExe = Join-Path $chocolateyPath 'choco.exe'
      if (Test-Path ($chocoExe)) {
        Write-Debug "Renaming '$chocoExe' to '$chocoExe.old'"
        Move-Item $chocoExe "$chocoExe.old" -force
      $chocInstallFolder = Join-Path $thisScriptFolder "chocolateyInstall"
      Copy-Item $chocInstallFolder\* $chocolateyPath -recurse -force
    function Ensure-ChocolateyLibFiles {
      $chocoPkgDirectory = Join-Path $chocolateyLibPath 'chocolatey'
      if ( -not (Test-Path("$chocoPkgDirectory\chocolatey.nupkg")) ) {
        Write-Output "Ensuring '$chocoPkgDirectory' exists."
        Create-DirectoryIfNotExists $chocoPkgDirectory
        $chocoPkg = Get-ChildItem "$thisScriptFolder/../../" | ?{$ -match "^chocolatey.*nupkg"} | Sort name -Descending | Select -First 1
        if ($chocoPkg -ne '') { $chocoPkg = $chocoPkg.FullName }
        "$tempDir\", "$chocoPkg" | % {
          if ($_ -ne $null -and $_ -ne '') {
            if (Test-Path $_) {
              Copy-Item $_ "$chocoPkgDirectory\chocolatey.nupkg" -force
    function Install-ChocolateyBinFiles {
      [string] $chocolateyPath,
      [string] $chocolateyExePath
      $redirectsPath = Join-Path $chocolateyPath 'redirects'
      $exeFiles = Get-ChildItem "$redirectsPath" -include @("*.exe","*.cmd") -recurse
      foreach ($exeFile in $exeFiles) {
        $exeFilePath = $exeFile.FullName
        $exeFileName = [System.IO.Path]::GetFileName("$exeFilePath")
        $binFilePath = Join-Path $chocolateyExePath $exeFileName
        $binFilePathRename = $binFilePath + '.old'
        $batchFilePath = $binFilePath.Replace(".exe",".bat")
        $bashFilePath = $binFilePath.Replace(".exe","")
        if (Test-Path ($batchFilePath)) { Remove-Item $batchFilePath -force }
        if (Test-Path ($bashFilePath)) { Remove-Item $bashFilePath -force }
        if (Test-Path ($binFilePathRename)) {
          try {
            Remove-Item $binFilePathRename -force
          catch {
            Write-Warning "Was not able to remove `'$binFilePathRename`'. This may cause errors."
        if (Test-Path ($binFilePath)) {
         try {
            Move-Item -path $binFilePath -destination $binFilePathRename -force
          catch {
            Write-Warning "Was not able to rename `'$binFilePath`' to `'$binFilePathRename`'."
        try {
          Copy-Item -path $exeFilePath -destination $binFilePath -force
        catch {
          Write-Warning "Was not able to replace `'$binFilePath`' with `'$exeFilePath`'. You may need to do this manually."
        $commandShortcut = [System.IO.Path]::GetFileNameWithoutExtension("$exeFilePath")
        Write-Debug "Added command $commandShortcut"
    function Initialize-ChocolateyPath {
      [string]$chocolateyExePath = "$($env:ALLUSERSPROFILE)\chocolatey\bin",
      [string]$chocolateyExePathVariable = "%$($chocInstallVariableName)%\bin"
      $environmentTarget = [System.EnvironmentVariableTarget]::User
      if (Test-ProcessAdminRights) {
        Write-Debug "Administrator installing so using Machine environment variable target instead of User."
        $environmentTarget = [System.EnvironmentVariableTarget]::Machine
      Install-ChocolateyPath -pathToInstall "$chocolateyExePath" -pathType $environmentTarget
    function Process-ChocolateyBinFiles {
      [string]$chocolateyExePath = "$($env:ALLUSERSPROFILE)\chocolatey\bin",
      [string]$chocolateyExePathVariable = "%$($chocInstallVariableName)%\bin"
      $processedMarkerFile = Join-Path $chocolateyExePath '_processed.txt'
      if (!(test-path $processedMarkerFile)) {
        $files = get-childitem $chocolateyExePath -include *.bat -recurse
        if ($files -ne $null -and $files.Count -gt 0) {
          foreach ($file in $files) {
            Write-Output "Processing $($file.Name) to make it portable"
            $fileStream = [System.IO.File]::Open("$file", 'Open', 'Read', 'ReadWrite')
            $reader = New-Object System.IO.StreamReader($fileStream)
            $fileText = $reader.ReadToEnd()
            $fileText = $fileText.ToLower().Replace("`"" + $chocolateyPath.ToLower(), "SET DIR=%~dp0%`n""%DIR%..\").Replace("\\","\")
            Set-Content $file -Value $fileText -Encoding Ascii
        Set-Content $processedMarkerFile -Value "$([System.DateTime]::Now.Date)" -Encoding Ascii
    function Install-DotNet4IfMissing {
      if ([IntPtr]::Size -eq 8) {$fx="framework64"} else {$fx="framework"}
      if (!(test-path "$env:windir\Microsoft.Net\$fx\v4.0.30319")) {
        $NetFx4ClientUrl = ''
        $NetFx4FullUrl = ''
        Install-ChocolateyPackage "NetFx4.0" 'exe' -silentArgs "/q /norestart /repair /log `'$tempDir\NetFx4Install.log`'" -url "$NetFx4ClientUrl" -url64bit "$NetFx4ClientUrl" -validExitCodes @(0, 3010)
    Export-ModuleMember -function Initialize-Chocolatey;
  • tools\init.ps1 Show
    param($installPath, $toolsPath, $package, $project)
    $modules = Get-ChildItem $ToolsPath -Filter *.psm1
    $modules | ForEach-Object { import-module -name  $_.FullName }
    Welcome to Chocolatey, your local machine repository built on the NuGet infrastructure. Chocolatey allows you to install application packages to your machine with the goodness of a #chocolatey #nuget combo. 
    Application executables get added to the path automatically so you can call them from anywhere (command line/powershell prompt), not just in Visual Studio.
    Lets get Chocolatey!
    Visual Studio -
    Please run Initialize-Chocolatey one time per machine to set up the repository. 
    If you are upgrading, please remember to run Initialize-Chocolatey again.
    After you have run Initiliaze-Chocolatey, you can safely uninstall the chocolatey package from your current Visual Studio solution.
    Alternative NuGet -
    If you are not using NuGet in Visual Studio, please navigate to the directory with the chocolateysetup.psm1 and run that in Powershell, followed by Initialize-Chocolatey.
    Upgrade is the same, just run Initialize-Chocolatey again.
    Once you've run initialize or upgrade, you can uninstall this package from the local project without affecting your chocolatey repository.
    "@ | Write-Host

Virus Scan Results

In cases where actual malware is found, the packages are subject to removal. Software sometimes has false positives. Moderators do not necessarily validate the safety of the underlying software, only that a package retrieves software from the official distribution point and/or validate embedded software against official distribution point (where distribution rights allow redistribution).

Chocolatey Pro provides runtime protection from possible malware.


This package has no dependencies.

Package Maintainer(s)

Software Author(s)

  • Rob Reynolds
  • The Chocolatey Team


RealDimensions Software, LLC - 2011-Present


Release Notes

See all -


This also includes issues that were being tracked in the old Chocolatey repository: chocolatey 0.9.9.

The two links above will not capture everything that has changed, since this is a complete rewrite. We broke everything. If this were a v1+, it would be a major release. But we are less than v1, so 0.9.9 it is! ;)

Of course we also fixed and improved a bunch of things, so we feel the trade off is well worth the changes.

We'll try to capture everything here that you should know about. Please call choco.exe -h to get started.


  • TEMPORARY install all is missing - this is expected to be back in 0.9.10 - see #23
  • Alternative sources (webpi,ruby,python,cygwin, windowsfeature) do not work yet. This is expected to be fixed in 0.9.10 - see #14
  • See Feature Parity for items not yet reimplemented from older PowerShell Chocolatey client (v0.9.8.32 and below).


  • [Security] Prompt for confirmation: For security reasons, we now stop for confirmation before changing the state of the system on most commands. You can pass -y to confirm any prompts.
  • [Security] If your default installation is still at C:\Chocolatey, this version will force a move to ProgramData and update the environment settings - see #7
  • Configuration Breaking Changes:

    1. You now have one config file to interact with in %ChocolateyInstall%\config - your user config is no longer valid and can be removed once you migrate settings to the config.

    2. The config will not be overwritten on upgrade.

    3. Choco no longer interacts with NuGet's config file at all. You will need to reset all of your apiKeys (see features for apikey). On the plus side, the keys will work for all users of the machine, unlike NuGet's apiKeys (only work for the user that sets them).

    4. This also means you can no longer use useNugetForSources. It has been removed as a config setting.

  • Packaging Changes:

    1. Choco now installs packages without version numbers on folders. This means quite a few things...

    2. Upgrading packages doesn't install a new version next to an old version, it actually upgrades.

    3. Dependencies resolve at highest available version, not the minimum version as before - see chocolatey #415

  • Package Maintenance Changes:

    1. Read the above about apikey changes

    2. Read above about dependency resolution changes.

    3. choco push requires a source now, so you must specify -s when pushing to the community feed - see Push Command

  • Deprecated/Removed Commands:

    1. installmissing has been removed. It was deprecated awhile ago, so this should not be a surprise.

    2. choco version has been removed. Use choco upgrade pkgName --noop instead.

    3. Write-ChocolateySuccess, Write-ChocolateyFailure have been deprecated.

    4. update is now upgrade. update has been removed for now but will be reincarnated later for a different purpose. Hint: It rhymes with smackage pindexes.

    5. sources is now source.

  • packages.config has a slightly different structure now. See Packages.config and #10
  • PowerShell - Ensure all errors are terminating errors - see #48



Probably a lot of bug fixes that may not make it here, but here are the ones we know about.


  • [Security] Allow keeping c:\chocolatey install directory with environment variable - see #17
  • [Security] Require switch on unofficial build - see #36
  • Install script updates - see #7
  • Ensure Chocolatey pkg is installed properly in lib folder - This means you can take a dependency on a minimum version of Chocolatey (we didn't like that before) - see #19
  • Uninstall - allow abort - see #43
  • Support for HTTPS basic authorization - see chocolatey #128
  • Smooth out success/failure logging - see chocolatey #154
  • Add $env:CHOCOLATEY_VERSION - see chocolatey #251
  • Replace ascii cue with visual cues - see chocolatey #376
  • Uninstall all versions of an app - see chocolatey #389
  • Add parameters in packages.config files - see chocolatey #472, Packages.config and #10
  • Choco pack should support -version - see chocolatey #526
  • Enhancements to Start-ChocolateyProcessAsAdmin - see chocolatey #564
  • Install-ChocolateyFileAssociation - add label to new file types - see chocolatey #564
  • Clean up the verobsity of Chocolatey - see chocolatey #374
  • Compact choco upgrade --noop option - see chocolatey #414
  • Remove references to the chocolatey gods - see chocolatey #669
  • Dat help menu tho. I mean srsly guise - see chocolatey #641

Version History

Version Downloads Last updated Status
Chocolatey 0.10.15-beta-20190531 637 Friday, May 31, 2019 approved
Chocolatey 0.10.14 506469 Thursday, May 30, 2019 approved
Chocolatey 0.10.14-beta-20190418 5115 Thursday, April 18, 2019 approved
Chocolatey 0.10.14-beta-20190402 2537 Tuesday, April 2, 2019 approved
Chocolatey 0.10.14-beta-20190321 2102 Friday, March 22, 2019 approved
Chocolatey 0.10.13 7562123 Friday, March 15, 2019 approved
Chocolatey 0.10.12 151723 Friday, March 15, 2019 approved
Chocolatey 0.10.12-beta-20181011 14751 Friday, October 12, 2018 approved
Chocolatey 0.10.12-beta-20181009 492 Tuesday, October 9, 2018 approved
Show More

Discussion for the Chocolatey Package

Ground rules:

  • This discussion is only about Chocolatey and the Chocolatey package. If you have feedback for Chocolatey, please contact the google group.
  • This discussion will carry over multiple versions. If you have a comment about a particular version, please note that in your comments.
  • The maintainers of this Chocolatey Package will be notified about new comments that are posted to this Disqus thread, however, it is NOT a guarantee that you will get a response. If you do not hear back from the maintainers after posting a message below, please follow up by using the link on the left side of this page or follow this link to contact maintainers. If you still hear nothing back, please follow the package triage process.
  • Tell us what you love about the package or Chocolatey, or tell us what needs improvement.
  • Share your experiences with the package, or extra configuration or gotchas that you've found.
  • If you use a url, the comment will be flagged for moderation until you've been whitelisted. Disqus moderated comments are approved on a weekly schedule if not sooner. It could take between 1-5 days for your comment to show up.

comments powered by Disqus uses cookies to enhance the user experience of the site.