Latest Release (3.27.7)
The release was packaged with CPack which is included as part of the release. The .sh files are self extracting gziped tar files. To install a .sh file, run it with /bin/sh and follow the directions. The OS-machine.tar.gz files are gziped tar files of the install tree. The OS-machine.tar.Z files are compressed tar files of the install tree. The tar file distributions can be untared in any directory. They are prefixed by the version of CMake. For example, the linux-x86_64 tar file is all under the directory cmake–linux-x86_64. This prefix can be removed as long as the share, bin, man and doc directories are moved relative to each other. To build the source distributions, unpack them with zip or tar and follow the instructions in README.rst at the top of the source tree. See also the CMake 3.27 Release Notes.
Source distributions:
| Platform | Files |
|---|---|
| Unix/Linux Source (has \n line feeds) | cmake-3.27.7.tar.gz |
| Windows Source (has \r\n line feeds) | cmake-3.27.7.zip |
Binary distributions:
| Platform | Files |
|---|---|
| Windows x64 Installer: | cmake-3.27.7-windows-x86_64.msi |
| Windows x64 ZIP | cmake-3.27.7-windows-x86_64.zip |
| Windows i386 Installer: | cmake-3.27.7-windows-i386.msi |
| Windows i386 ZIP | cmake-3.27.7-windows-i386.zip |
| Windows ARM64 Installer: | cmake-3.27.7-windows-arm64.msi |
| Windows ARM64 ZIP | cmake-3.27.7-windows-arm64.zip |
| macOS 10.13 or later | cmake-3.27.7-macos-universal.dmg |
| cmake-3.27.7-macos-universal.tar.gz | |
| macOS 10.10 or later | cmake-3.27.7-macos10.10-universal.dmg |
| cmake-3.27.7-macos10.10-universal.tar.gz | |
| Linux x86_64 | cmake-3.27.7-linux-x86_64.sh |
| cmake-3.27.7-linux-x86_64.tar.gz | |
| Linux aarch64 | cmake-3.27.7-linux-aarch64.sh |
| cmake-3.27.7-linux-aarch64.tar.gz |
Summary files:
| Role | Files |
|---|---|
| File Table v1 | cmake-3.27.7-files-v1.json |
| Cryptographic Hashes | cmake-3.27.7-SHA-256.txt |
| PGP sig by 2D2CEF1034921684 | cmake-3.27.7-SHA-256.txt.asc |
Previous Release (3.26.5)
The release was packaged with CPack which is included as part of the release. The .sh files are self extracting gziped tar files. To install a .sh file, run it with /bin/sh and follow the directions. The OS-machine.tar.gz files are gziped tar files of the install tree. The OS-machine.tar.Z files are compressed tar files of the install tree. The tar file distributions can be untared in any directory. They are prefixed by the version of CMake. For example, the linux-x86_64 tar file is all under the directory cmake–linux-x86_64. This prefix can be removed as long as the share, bin, man and doc directories are moved relative to each other. To build the source distributions, unpack them with zip or tar and follow the instructions in README.rst at the top of the source tree. See also the CMake 3.26 Release Notes.
Source distributions:
| Platform | Files |
|---|---|
| Unix/Linux Source (has \n line feeds) | cmake-3.26.5.tar.gz |
| Windows Source (has \r\n line feeds) | cmake-3.26.5.zip |
Binary distributions:
| Platform | Files |
|---|---|
| Windows x64 Installer: | cmake-3.26.5-windows-x86_64.msi |
| Windows x64 ZIP | cmake-3.26.5-windows-x86_64.zip |
| Windows i386 Installer: | cmake-3.26.5-windows-i386.msi |
| Windows i386 ZIP | cmake-3.26.5-windows-i386.zip |
| Windows ARM64 Installer: | cmake-3.26.5-windows-arm64.msi |
| Windows ARM64 ZIP | cmake-3.26.5-windows-arm64.zip |
| macOS 10.13 or later | cmake-3.26.5-macos-universal.dmg |
| cmake-3.26.5-macos-universal.tar.gz | |
| macOS 10.10 or later | cmake-3.26.5-macos10.10-universal.dmg |
| cmake-3.26.5-macos10.10-universal.tar.gz | |
| Linux x86_64 | cmake-3.26.5-linux-x86_64.sh |
| cmake-3.26.5-linux-x86_64.tar.gz | |
| Linux aarch64 | cmake-3.26.5-linux-aarch64.sh |
| cmake-3.26.5-linux-aarch64.tar.gz |
Summary files:
| Role | Files |
|---|---|
| File Table v1 | cmake-3.26.5-files-v1.json |
| Cryptographic Hashes | cmake-3.26.5-SHA-256.txt |
| PGP sig by 2D2CEF1034921684 | cmake-3.26.5-SHA-256.txt.asc |
Alternative Binary Releases
| Host | Link |
|---|---|
| Kitware’s Ubuntu packages | https://apt.kitware.com/ |
| snap | https://snapcraft.io/cmake |
| pip | https://pypi.org/project/cmake/ |
Older Releases
| Host | Link |
|---|---|
| kitware | https://cmake.org/files |
| github | https://github.com/Kitware/CMake/releases |
Editor Syntax Files
| Editor | Files |
|---|---|
| emacs | cmake-mode.el |
| vim | vim-cmake-syntax |
Current development distribution
Each night binaries are created as part of the testing process. Other than passing all of the tests in CMake, this version of CMake should not be expected to work in a production environment. It is being produced so that users can test bug fixes done upstream without having to build CMake.
| Nightly Binaries | Link |
|---|---|
| https | https://cmake.org/files/dev/ |
Alternatively one may build from source. Development is managed on Kitware’s GitLab instance:
- https://gitlab.kitware.com/cmake/cmake
On UNIX, one may use the bootstrap script provided in the source tree to build CMake. In order to build the Windows version of CMake, you will need a current binary installation of CMake to bootstrap the build process.
We’re Earthly. We make building software simpler and faster with containerization. If you’re into CMake and automation, Earthly could be just the tool you need. Check it out.
CMake is an open source multiplatform tool that you can use to help with build automation, testing, packaging, and the installation of software. One of the main advantages of CMake is that it supports generating build scripts for a wide variety of platforms including Windows, macOS, and Linux. This gives developers the flexibility they need when building a new project and hopefully helps speed up the build.
In this article, you’ll learn more about CMake and if it’s the right solution for you. You’ll also walk through the process of installing it on Windows.
Pros and Cons of CMake
There are a number of benefits to using CMake to help build your solutions, including the fact that CMake can run on all major platforms, including Windows, Linux, and macOS. This means that a team of developers who are using different operating systems can still have common development tools.
Using CMake for projects, instead of something like Visual Studio projects, helps you avoid being locked into one integrated development environment (IDE). A team can create a project using CMake, and then each developer can use their preferred IDE to work on it. CMake integration is supported by a variety of IDE tools, including CLion, Atom, and Visual Studio.
It may be useful for some developers and software architects to understand what dependencies are within their projects and the nature of the dependency. CMake can create a visualization of any dependencies within the project, that you can use to create documentation.
While many would assume that CMake’s active development is an advantage (which it is!), it also has its downsides: Not everyone within a developer team will be running the same version of CMake. However, to help reduce this issue, CMake has introduced policies that define how certain CMake features should behave. This means your team can set a common policy regardless of what version people are using.
Another disadvantage of CMake is the lack of information available for some versions. It can be hard to find accurate information to resolve an issue or answer a question.
When to Use CMake
As you can see, CMake can be a useful build system. Developers using CMake can quickly check performance on different build backends and easily move between them.
CMake can also help to keep your source code folder clean. It can separate the build system, intermediaries, and output files from the source code, keeping your code clean for the future.
Install CMake on Windows
There are several ways to install CMake on Windows. The first option is to use pre-compiled binaries as either the Windows Installer file (MSI) or the compressed version (ZIP) files. You just have to download the files and then walk through the interactive installation wizard.
The second option is to download and build CMake from the source, and CMake even includes a source release download option.
The third option is to use a package manager tool, such as Windows Package Manager or Chocolatey. This can be especially convenient if you already have either installed on your machine. We will use the package manager method you’ll use for your installation here.
If you’re using Windows Package Manager, run the following command to install CMake:
winget install kitware.cmakeIf you’re using Chocolatey, use the following command:
Install a CMake Extension with Visual Studio
Once you’ve finished installing CMake on Windows, you need to install an extension that lets you integrate the functionality of CMake into your IDE (Visual Studio is used here).
To install the CMake extension, you need to select Start and then open the Visual Studio Installer from the menu:
Once the Visual Studio Installer loads, select Modify:
Under Workloads, locate Desktop development with C++, which can be found under Desktop & Mobile:
On this same page, you also need to find and select the Linux and embedded development with C++ component. This component ensures you have cross-platform CMake development capabilities:
Once you’ve selected both, select Modify again, and the additional tools will be installed.
Integrate an IDE
Now that you’ve installed CMake and a few components, it’s time to use them. Start a new project by opening Visual Studio and selecting Create a new project > CMake project:
After selecting CMake project, Visual Studio, and CMake will create a directory and a file called CMakeLists.txt, which is a set of instructions describing certain settings within the project, such as source files and targets.
When Visual Studio detects that there is a CMakeLists.txt file within a project that’s been opened, it adds CMake items to the Project menu, which gives you access to commands for viewing and editing CMake scripts:
Configure CMake Projects
CMake supports two files that let you specify build and test options. These files are CMakePresets.json and CMakeUserPresets.json. Microsoft recommends that you use CMakePresets.json.
To ensure that Visual Studio uses the CMakePresets.json file, you need to enable it. You can do so via Tools > Options > CMake > General. Please ensure that the Always use CMake Presets option is selected:
If Visual Studio can’t find a CMakePresets.json file, it will fall back to using the default configure presets.
There are three key settings within your CMakePresets.json file: target systems, configure presets, and build presets. The target system is the system on which CMake is invoked to configure and build your project. You can use systems installed on your local machine, SSH connections, and all Windows Subsystem for Linux (WSL) installations.
The configure preset option is used when CMake is invoked to generate the project build system. Depending on your target system, the options for this will change. So if you are using Ubuntu as your target system, your configure preset could be Linux debug.
The build preset value is used when CMake is invoked to build the project and should align with the configure preset. If Visual Studio can’t find any build presets that are associated with the configure preset, then it will provide the default build preset.
As you can see, there are a lot of options available to configure your CMake projects to suit your needs and project. If you’re looking for even more information on how to configure your projects, check out this Visual Studio documentation.
Build CMake Projects on Visual Studio
When you’re ready, Visual Studio gives you several options to build your CMake projects, including the toolbar or the Solution Explorer.
If you want to use the toolbar, you need to find the Startup Item drop-down:
Select your preferred target to build, and either press F5 or choose Run.
If you want to use the Solution Explorer, navigate to the Solution Explorer on the right-hand side of your screen. By default, it will be set to the Folder View:
You need to change the Folder View to the CMake Targets View. To do this, select the view icon:
Then select CMake Targets View:
Then right-click on CMake Target and select Build from the context menu:
Lastly, you can select Build > Build All from the main menu of Visual Studio to build your CMake project:
After completing either one of these options, you can find the build results within the Output window and Error List:
Debug CMake Projects
As you know, when writing code, it’s never perfect the first time, which is why you’ll need to be able to debug your code.
To debug your CMake project using Visual Studio, start by selecting one of the targets shown in the Startup Item drop-down within the toolbar:
Then select Debug > Start Debugging from the main toolbar:
If any changes have been made since the last time you built the project, the debug command will build it first before the debugging can take place.
The launch.vs.json file can be used to customize your CMake debugging session. This file can be used to input any environment variables or command line arguments that you might want to pass into the program during debugging.
Conclusion
CMake is a versatile tool that aids in build automation, testing, packaging, and software installation. It integrates with many IDEs, giving developers the flexibility to stick with their preferred IDE. It ensures your application’s compatibility across any platform. While CMake isn’t for everyone, it can be a robust solution for the right developer or project.
And if you’re looking to optimize your builds further, you might want to give Earthly a shot for its efficient caching and straightforward syntax.
Earthly makes builds simple
Fast, repeatable builds with an instantly familiar syntax – like Dockerfile and Makefile had a baby.
Learn More
CMake Tools
CMake Tools provides the native developer a full-featured, convenient, and powerful workflow for CMake-based projects in Visual Studio Code.
Important doc links
- CMake Tools quick start
- Configure and build a project with CMake Presets
- Configure a project with kits and variants
- Build a project with kits and variants
- Configure and build a project using tasks
- Debug a project
- Configure CMake Tools settings
- How to
- FAQ
- Read the online documentation
- Contribute
Issues? Questions? Feature requests?
PLEASE, if you experience any problems, have any questions, or have an idea
for a new feature, create an issue on the GitHub page!
This extension itself does not provide language support for the CMake scripting language.
For that we bundle this extension which provides the support.
A closed-source extension that provides even better support can also be installed: CMake Language Support
Microsoft Open Source Code of Conduct
This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.
Data/Telemetry
This extension collects usage data and sends it to Microsoft to help improve our products and services. Collection of telemetry is controlled via the same setting provided by Visual Studio Code: "telemetry.enableTelemetry". Read our privacy statement to learn more.
Credits
This project was started by @vector-of-bool and is now currently maintained by Microsoft.
CMake is a SCons for automating compilation tasks.
CMake is a system to automate compilation tasks of code files created in C and C++.
On Unix type systems we can say that it is a “Makefile” generator. He is classified as a SCons.
We already made a brief introduction here on the blog about CMake, but it is also possible to generate Makefiles in Windows, although CMake also generates files for Visual Studio.
Today we will see how to install CMake on Windows.
Dependencies
As in this example we will use GCC, it is important that you have it installed on your Windows via MinGW, see here how to do it.
Now let’s go step by step!
Installation
01. Download CMake by clicking the button below:
Download CMake for Windows 64-bit
After downloading, double-click on the downloaded file: cmake-3.26.0-rc6-windows-x86_64.msi and give administrator permissions to start the installation setup.
02. Setup presentation
Just click on
Next.
03. Accept the license terms
And then click
Next.
04. Add CMake to your PATH
Check the Add CMake to the system PATH for all users option for the command to be available to all system users. And then click on Next.
05. Select installation path
Hint: Keep what already appears and click
Next.
06. Start the installation
Click on Install and wait for the installation to finish.
Installing:
Once finished, click on
Finish:
Testing CMake
Open PowerShell or CMD and type the command:
cmake --versionIf the output is similar to the image below, everything is right and installed perfectly:
Compiling with CMake
-
Create a folder, for example
MyProject, enter it (by CMD or PowerShell,cd MyProject) and inside it do: -
Create a file named
CMakeLists.txtwith your Preferred Code Editor or IDE and fill it with the code below:
cmake_minimum_required(VERSION 3.10)
project(HelloWorld)
add_executable(hello main.cpp)
- Also create a
main.cppfile with a basic code, example:
#include <iostream>
auto main(int argc, char** argv) -> int {
std::printf("CMake is working on Windows!\n");
return EXIT_SUCCESS;
}
At the end your MyProject folder will have 2 files: CMakeLists.txt and main.cpp as shown in the image below:
- Now run the command:
cmake -G "Unix Makefiles" -B buildIt will create a folder called
buildinside your project. If you don’t say-G "Unix Makefiles"it will prepare files for Visual Studio, in which case we want a Unix-like Makefile.
The output will be similar to the image below:
- Once finished, enter the build folder (
cd build) and run themakecommand (if this command does not exist, it is because you did not rename the MinGW file to that name as mentioned in the article about MinGW cited above, then most likely the command will bemingw32-make). And then run the final binary:hello:
That’s it, now you can compile your C and C++ code with CMake!
Useful links
- https://cmake.org/
- https://cmake.org/download/
- https://github.com/Kitware/CMake/
cmake
windows
First written on 2020-09-11.
Last updated on 2021-01-02.
In this article and several more, I will be discussing developing a very simple C++ library and application using CMake and Visual Studio Code. I will also use git and Google Test, and port the project from Windows to Linux. Most of the information is applicable to using almost any IDE, or indeed, no IDE at all.
Why Use CMake?
CMake is a powerful and robust build system. You specify what you want done, not how to do it. CMake then takes that information and generates the files needed to build the system. For example, CMake can generate solution (.sln) and project files (.vcxproj) that Visual Studio and Visual Studio Code use on Windows. Similar capabilities are available for every other popular IDE. It can even create make files if you want to do everything from the command line. Because it can be called from the command line, it integrates well with continuous integration/continuous build systems.
You can specify the build tools that you want to use; for example, you can use MSVC or LLVM on Windows, and gnu or LLVM on Unix-like systems, including Linux, OSX, and MSYS or MinGW. Aside from specifying the tools to use, no other changes are required to the CMake specification files. You will see this when I port my project from Windows using the Visual Studio build tools to Linux using the gnu build tools.
With CMake, you can download, build, and use a large number of tools. I will show one example of this when I use Google Test in this project. Just about any tool that can be downloaded from the internet, and which provides CMake files for building, can be used.
Installing the Needed Tools
I will start the project on Windows using VS Code and the Visual Studio Build Tools, but if you wish, you can start with a different IDE, or even a different operating system. In a later article, I will discuss using the gnu tools on Linux (Ubuntu).
So let’s begin.
Installing Visual Studio Code and Extensions
On Windows, the latest version of Visual Studio Code is available on its download page. Select the appropriate version; click on the Windows button for the x64 version, or one of the ARM links for ARM if that is applicable to you. The download will begin. When it is completed, run the downloaded file.
Next, we need two VSCode extensions. Start VS Code and display the extensions panel (select View → Extensions from the main menu). In the search box, enter C++. A number of C and C++ extensions are displayed. You want the one called C++. Make sure it is from Microsoft. This extension provides Intellisense, debugging, and browsing capabilities. Click on the Install button to install it.
The second extension is CMake Tools. Search for and install it.
Installing Visual Studio Build Tools
We need the build tools provided by Visual Studio. Don’t worry, we aren’t installing Visual Studio, just the build tools.
On the Visual Studio downloads page, move down into the All Downloads section. As I write this, the current version of Visual Studio is 2019, so I will be referring to it in this section. If a later version is available, use that instead. Select Tools for Visual Studio 2019. Click on the Download button for Build Tools for Visual Studio 2019. Download and save the file. When the download has completed, open the file. This starts Visual Studio Installer. Again, don’t worry, we are not installing Visual Studio, just the build tools. When the installer window opens select only the build tools. After some time (several minutes), the install will complete. Close the installer.
Open the Windows Start menu and start Developer Command Prompt for VS 2019; do not open the standard command prompt or Powershell. At the command prompt, enter:
cmake --versionThe following should be displayed, although the version number may be different:
cmake version 3.17.20032601-MSVC_2
CMake suite maintained and supported by Kitware (kitware.com/cmake).If the message says that it cannot find CMake, then the build tools did not install correctly.
You will almost always be starting VS Code from the command line of Developer Command Prompt, so you will probably want to add it to the Productivity section of the Start menu.
Installing Git
We will need git. If you have done any development work, you probably already have it installed. If not, Git for Windows is available here.
A Simple C++ Program With Library
We will start by creating a simple C++ program with a simple library. You can perform similar steps, with slight modifications, if you are on Linux or any other Unix-like system. To support the program, we will create a directory structure and start VS Code as follows:
Open a Developer Command Prompt. Enter:
cd c:\Users\xxx #where xxx is your Windows user name
mkdir Projects # if you have not previously created a projects directory
cd Projects
mkdir vscode-cmake-hello
cd vscode-cmake-hello
mkdir apps
mkdir hello
cd hello
mkdir include
mkdir src
cd .. # return to c:\Users\xxx\Projects\hello
git init # initialize git for the project
code . # start VS CodeIn the Explorer list in VS Code, select the hello/include directory and create a new file called hello.h. Place the following code in that file and save it:
#pragma once
#include <string>
const std::string generateHelloString(const std::string & personName);
Again in the Explorer list, select hello/src and create a new file called hello.cpp. Place the following code in that file and save it:
#include "hello.h"
using namespace std;
const string generateHelloString(const string & personName)
{
return "Hello " + personName;
}That is all the code we need for our library. Now create the program to use the library. In the Explorer list, select the apps directory and create a new file called main.cpp. Place the following code in that file and save it:
#include <iostream>
#include "hello.h"
int main(int, char**) {
std::string helloJim = generateHelloString("Jim");
std::cout << helloJim << std::endl;
return 0;
}To build the library and program, we will use CMake. There are many examples of CMake on the internet, many of which are outdated or just plain bad. For this program and library, I am following Modern CMake by Henry Schreiner and others.
In the Explorer list, select VSCODE-CMAKE-HELLO in VS Code and create a new file. Call it CMakeLists.txt. Enter the following and save the file:
# version 3.11 or later of CMake needed later for installing GoogleTest
# so let's require it now.
cmake_minimum_required(VERSION 3.11-3.18)
project(
VscodeCmakeHello
VERSION 0.1
DESCRIPTION "Small CMake example built with VSCode")
add_subdirectory(hello) # look in hello subdirectory for CMakeLists.txt to process
add_subdirectory(apps) # look in apps subdirectory for CMakeLists.txt to processIn the Explorer list, select apps and create a new file. Call it CMakeLists.txt. Enter the following and save the file:
# version 3.11 or later of CMake or needed later for installing GoogleTest
# so let's require it now.
cmake_minimum_required(VERSION 3.11-3.18)
project(main)
add_executable(main main.cpp)
# We need hello.h and the hello library
target_link_libraries(main
PRIVATE hello)
# Tell C++ compiler to use C++20 features. We don't actually use any of them.
target_compile_features(main PUBLIC cxx_std_20)Create a file called CMakeLists.txt in the hello directory and place the following code in it:
# version 3.11 or later of CMake or needed later for installing GoogleTest
# so let's require it now.
cmake_minimum_required(VERSION 3.11-3.18)
project(hello)
add_library(hello src/hello.cpp)
# PUBLIC needed to make both hello.h and hello library available elsewhere in project
target_include_directories(${PROJECT_NAME}
PUBLIC ${PROJECT_SOURCE_DIR}/include)
# Tell compiler to use C++20 features. The code doesn't actually use any of them.
target_compile_features(hello PUBLIC cxx_std_20)Look at the status bar on the VS Code window. If it looks similar to this:
then terminate and restart VS Code. The status bar should now look like this:
From left to right, master* indicates that you are editing the git master branch and that changes have been made. The symbols and 0s indicate that there are currently no errors in workspace. Next is a button that will run CMake (CMake: [Debug]). No Kit Selected indicates that the build tools have not yet been selected; we will get to them in a moment. Following that is a Build button, the default target, a bug button that will run the application in debug mode, and a button that will run the application without starting the debugger. The remainder of the status bar provides other information that we are not currently concerned with.
We first have to run CMake to create the build files. Click on the CMake: [Debug] button. The first time you do so, a list of build tool kits is displayed below the main menu. Select either Unspecified, or Visual Studio Build Tools 2019 Release - amd64. The No Kit Selected text in the status bar will change to [Visual Studio Build Tools 2019 Release - amd64], and a list of CMake configurations are displayed: Debug, Release, MinSizeRel, and RelWithDebInfo.
Select Debug. This will execute CMake and generate a Visual Studio solution file (.sln) and Visual Studio project files (.vcxproj) if there are no errors. If there are errors, then something is not right with the CMakeLists.txt files or the C++ source files.
If you selected any of the other CMake actions, the executable, library, and debug related files would be placed in other subdirectories. For example, if you build release versions, they will be placed in build/Release.
The first time you run debugging by either clicking on the Bug button, or by selecting Run → Start Debugging, a list of build environments will be displayed just below the main menu. Select C++ (Windows).
To do a clean and rebuild, all we have to do is delete the build directory and all of its contents, then run CMake and Build.
Debugging
After a debug build, you can debug main.exe by clicking on the bug button in the status bar. Alternatively, you can select Run → Start Debugging from the main menu. In the latter case, the first time you do this, a list of debug environments is displayed. Select C++ (Windows). If the active file in VS Code is a C++ source file, a list of configurations is then displayed. You can select either cl.exe - Build and debug active file or Default configuration. If a different type of file is active, such as CMakeLists.txt, then the configuration list is not displayed.
In either case, a file called launch.json is added to the .vscode directory. Open that file and change the program to ${workspaceFolder}/build/apps/Debug/main.exe
Now you can run debug from either the bug button or the menu item.
Summary and What’s Next
This article discussed how to create a C++ project containing a program called main and a library called hello with Visual Studio Code using CMake. How to debug the program is also discussed.
There is still much to do, but that will be discussed in the following articles:
- Creating a Shared Library
- Adding GoogleTest to the project.
- Saving The Project to Source Control
- Porting The Project to Linux
UPDATES
The code in hello.cpp was updated to correct a typo. Thanks Vlad T. for pointing that out.