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




Downloads of v 0.9.9-alpha-20150125


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 1/25/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 (, and 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 at:

  • Search - choco search something
  • List - choco list -lo
  • Install - choco install baretail
  • Update - choco update baretail
  • Uninstall - choco uninstall baretail
  • 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

More advanced commands and switches listed on 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!

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

Chocolatey gods?

Humor related to playing off of tiki gods. We like humor. Don't take life so seriously, you will never get out alive.

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

C:\> choco install chocolatey --version 0.9.9-alpha-20150125 --pre

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

C:\> choco upgrade chocolatey --version 0.9.9-alpha-20150125 --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"
    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)) { Move-Item -path $binFilePath -destination $binFilePathRename -force }
        Copy-Item -path $exeFilePath -destination $binFilePath -force
        $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 -



  • Everything. Brand new executable. Time to learn choco again. Please call choco.exe -h to get started.

Version History

Version Downloads Last updated Status
Chocolatey 0.10.9-beta-20180223 2249 Friday, February 23, 2018 approved
Chocolatey 0.10.8-beta-20170806 4334 Monday, August 7, 2017 approved
Chocolatey 0.10.7 18299135 Thursday, June 8, 2017 approved
Chocolatey 844900 Saturday, June 3, 2017 approved
Chocolatey 0.10.6 412560 Thursday, June 1, 2017 approved
Chocolatey 0.10.6-beta-20170531 441 Thursday, June 1, 2017 approved
Chocolatey 0.10.6-beta-20170503 7530 Wednesday, May 3, 2017 approved
Chocolatey 0.10.5 18026376 Thursday, March 30, 2017 approved
Chocolatey 0.10.4 173642 Thursday, March 30, 2017 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.