Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
CMAKE-GENERATORS(7)		     CMake		   CMAKE-GENERATORS(7)

NAME
       cmake-generators	- CMake	Generators Reference

INTRODUCTION
       A  CMake	Generator is responsible for writing the input files for a na-
       tive build system.  Exactly one of the CMake  Generators	 must  be  se-
       lected  for a build tree	to determine what native build system is to be
       used.  Optionally one of	the Extra Generators  may  be  selected	 as  a
       variant	of  some  of the Command-Line Build Tool Generators to produce
       project files for an auxiliary IDE.

       CMake Generators	are platform-specific so each may be available only on
       certain	platforms.  The	cmake(1) command-line tool --help output lists
       available generators on the current platform.  Use  its	-G  option  to
       specify	the  generator	for a new build	tree.  The cmake-gui(1)	offers
       interactive selection of	a generator when creating a new	build tree.

CMAKE GENERATORS
   Command-Line	Build Tool Generators
       These generators	support	command-line build tools.   In	order  to  use
       them,  one  must	launch CMake from a command-line prompt	whose environ-
       ment is already configured for the chosen compiler and build tool.

   Makefile Generators
   Borland Makefiles
       Generates Borland makefiles.

   MSYS	Makefiles
       Generates makefiles for use with	MSYS (Minimal SYStem) make  under  the
       MSYS shell.

       Use  this  generator in a MSYS shell prompt and using make as the build
       tool.  The generated makefiles use /bin/sh as the shell to launch build
       rules.  They are	not compatible with a Windows command prompt.

       To build	under a	Windows	command	prompt,	use the	MinGW Makefiles	gener-
       ator.

   MinGW Makefiles
       Generates makefiles for use with	mingw32-make under a  Windows  command
       prompt.

       Use  this generator under a Windows command prompt with MinGW (Minimal-
       ist GNU for Windows) in the PATH	and using mingw32-make	as  the	 build
       tool.  The generated makefiles use cmd.exe as the shell to launch build
       rules.  They are	not compatible with MSYS or a unix shell.

       To build	under the MSYS shell, use the MSYS Makefiles generator.

   NMake Makefiles
       Generates NMake makefiles.

   NMake Makefiles JOM
       Generates JOM makefiles.

   Unix	Makefiles
       Generates standard UNIX makefiles.

       A hierarchy of UNIX makefiles is	generated into the  build  tree.   Use
       any  standard  UNIX-style make program to build the project through the
       all target  and	install	 the  project  through	the  install  (or  in-
       stall/strip) target.

       For  each  subdirectory	sub/dir	of the project a UNIX makefile will be
       created,	containing the following targets:

       all    Depends on all targets required by the subdirectory.

       install
	      Runs the install step in the subdirectory, if any.

       install/strip
	      Runs  the	 install  step	in  the	 subdirectory  followed	 by  a
	      CMAKE_STRIP command, if any.

	      The CMAKE_STRIP variable will contain the	platform's strip util-
	      ity, which removes symbols information from generated binaries.

       test   Runs the test step in the	subdirectory, if any.

       package
	      Runs the package step in the subdirectory, if any.

   Watcom WMake
       Generates Watcom	WMake makefiles.

   Ninja Generators
   Ninja
       Generates build.ninja files.

       A build.ninja file is generated into the	build  tree.   Use  the	 ninja
       program	to  build  the	project	through	the all	target and install the
       project through the install (or install/strip) target.

       For each	subdirectory sub/dir of	the project,  additional  targets  are
       generated:

       sub/dir/all
	      Depends on all targets required by the subdirectory.

       sub/dir/install
	      Runs the install step in the subdirectory, if any.

       sub/dir/install/strip
	      Runs  the	 install  step	in  the	 subdirectory  followed	 by  a
	      CMAKE_STRIP command, if any.

	      The CMAKE_STRIP variable will contain the	platform's strip util-
	      ity, which removes symbols information from generated binaries.

       sub/dir/test
	      Runs the test step in the	subdirectory, if any.

       sub/dir/package
	      Runs the package step in the subdirectory, if any.

   Fortran Support
       The  Ninja generator conditionally supports Fortran when	the ninja tool
       is at least version 1.10	(which has the required	features).

   See Also
       The Ninja Multi-Config generator	is similar to the Ninja	generator, but
       generates multiple configurations at once.

   Ninja Multi-Config
       Generates multiple build-<Config>.ninja files.

       This generator is very much like	the Ninja generator, but with some key
       differences. Only these differences will	be discussed in	this document.

       Unlike the Ninja	generator, Ninja Multi-Config generates	multiple  con-
       figurations  at once with CMAKE_CONFIGURATION_TYPES instead of only one
       configuration with CMAKE_BUILD_TYPE. One	build-<Config>.ninja file will
       be  generated for each of these configurations (with <Config> being the
       configuration name.) These files	are intended to	be run with  ninja  -f
       build-<Config>.ninja.  A	 build.ninja file is also generated, using the
       configuration from either CMAKE_DEFAULT_BUILD_TYPE or  the  first  item
       from CMAKE_CONFIGURATION_TYPES.

       cmake  --build .	--config <Config> will always use build-<Config>.ninja
       to build. If no --config	argument is specified, cmake  --build  .  will
       default	to  build-Debug.ninja,	unless a build.ninja is	generated (see
       below), in which	case that will be used instead.

       Each build-<Config>.ninja file contains <target>	 targets  as  well  as
       <target>:<Config> targets, where	<Config> is the	same as	the configura-
       tion specified in build-<Config>.ninja  Additionally,  if  cross-config
       mode  is	 enabled, build-<Config>.ninja may contain <target>:<OtherCon-
       fig> targets, where <OtherConfig> is a cross-config, as well  as	 <tar-
       get>:all,  which	 builds	the target in all cross-configs. See below for
       how to enable cross-config mode.

       The Ninja Multi-Config generator	recognizes the following variables:

       CMAKE_CONFIGURATION_TYPES
	      Specifies	the total set of configurations	to build.

       CMAKE_CROSS_CONFIGS
	      Specifies	a semicolon-separated list of configurations available
	      from all build-<Config>.ninja files.

       CMAKE_DEFAULT_BUILD_TYPE
	      Specifies	 the  configuration to use by default in a build.ninja
	      file.

       CMAKE_DEFAULT_CONFIGS
	      Specifies	a semicolon-separated list of configurations to	 build
	      for a target in build.ninja if no	:<Config> suffix is specified.

       Consider	the following example:

	  cmake_minimum_required(VERSION 3.16)
	  project(MultiConfigNinja C)

	  add_executable(generator generator.c)
	  add_custom_command(OUTPUT generated.c	COMMAND	generator generated.c)
	  add_library(generated	${CMAKE_BINARY_DIR}/generated.c)

       Now  assume  you	 configure the project with Ninja Multi-Config and run
       one of the following commands:

	  ninja	-f build-Debug.ninja generated
	  # OR
	  cmake	--build	. --config Debug --target generated

       This would build	the Debug configuration	of generator, which  would  be
       used  to	 generate  generated.c,	which would be used to build the Debug
       configuration of	generated.

       But if CMAKE_CROSS_CONFIGS is set to all, and you run the following in-
       stead:

	  ninja	-f build-Release.ninja generated:Debug
	  # OR
	  cmake	--build	. --config Release --target generated:Debug

       This would build	the Release configuration of generator,	which would be
       used to generate	generated.c, which would be used to  build  the	 Debug
       configuration  of generated. This is useful for running a release-opti-
       mized version of	a generator utility while  still  building  the	 debug
       version of the targets built with the generated code.

   IDE Build Tool Generators
       These  generators  support  Integrated  Development  Environment	 (IDE)
       project files.  Since the IDEs configure	their own environment one  may
       launch CMake from any environment.

   Visual Studio Generators
   Visual Studio 6
       Removed.	  This	once  generated	Visual Studio 6	project	files, but the
       generator has been removed since	CMake 3.6.  It is  still  possible  to
       build with VS 6 tools using the NMake Makefiles generator.

   Visual Studio 7
       Removed.	  This	once  generated	Visual Studio .NET 2002	project	files,
       but the generator has been removed since	CMake 3.6.  It is still	possi-
       ble to build with VS 7.0	tools using the	NMake Makefiles	generator.

   Visual Studio 7 .NET	2003
       Removed.	  This	once  generated	Visual Studio .NET 2003	project	files,
       but the generator has been removed since	CMake 3.9.  It is still	possi-
       ble to build with VS 7.1	tools using the	NMake Makefiles	generator.

   Visual Studio 8 2005
       Removed.	  This	once generated Visual Studio 8 2005 project files, but
       the generator has been removed since CMake 3.12.	 It is still  possible
       to build	with VS	2005 tools using the NMake Makefiles generator.

   Visual Studio 9 2008
       Generates Visual	Studio 9 2008 project files.

   Platform Selection
       The default target platform name	(architecture) is Win32.

       The  CMAKE_GENERATOR_PLATFORM  variable	may  be	 set,  perhaps via the
       cmake(1)	-A option, to specify a	target platform	 name  (architecture).
       For example:

       o cmake -G "Visual Studio 9 2008" -A Win32

       o cmake -G "Visual Studio 9 2008" -A x64

       o cmake -G "Visual Studio 9 2008" -A Itanium

       o cmake	-G  "Visual  Studio  9	2008" -A <WinCE-SDK> (Specify a	target
	 platform matching a Windows CE	SDK name.)

       For compatibility with CMake versions prior to 3.1, one may  specify  a
       target platform name optionally at the end of the generator name.  This
       is supported only for:

       Visual Studio 9 2008 Win64
	      Specify target platform x64.

       Visual Studio 9 2008 IA64
	      Specify target platform Itanium.

       Visual Studio 9 2008 <WinCE-SDK>
	      Specify target platform matching a Windows CE SDK	name.

   Visual Studio 10 2010
       Generates Visual	Studio 10 (VS 2010) project files.

       For compatibility with CMake versions prior to  3.0,  one  may  specify
       this  generator using the name Visual Studio 10 without the year	compo-
       nent.

   Project Types
       Only Visual C++ and C# projects	may  be	 generated.   Other  types  of
       projects	(Database, Website, etc.) are not supported.

   Platform Selection
       The default target platform name	(architecture) is Win32.

       The  CMAKE_GENERATOR_PLATFORM  variable	may  be	 set,  perhaps via the
       cmake(1)	-A option, to specify a	target platform	 name  (architecture).
       For example:

       o cmake -G "Visual Studio 10 2010" -A Win32

       o cmake -G "Visual Studio 10 2010" -A x64

       o cmake -G "Visual Studio 10 2010" -A Itanium

       For  compatibility  with	CMake versions prior to	3.1, one may specify a
       target platform name optionally at the end of the generator name.  This
       is supported only for:

       Visual Studio 10	2010 Win64
	      Specify target platform x64.

       Visual Studio 10	2010 IA64
	      Specify target platform Itanium.

   Toolset Selection
       The  v100  toolset that comes with Visual Studio	10 2010	is selected by
       default.	 The CMAKE_GENERATOR_TOOLSET option may	be  set,  perhaps  via
       the cmake(1) -T option, to specify another toolset.

   Visual Studio 11 2012
       Generates Visual	Studio 11 (VS 2012) project files.

       For  compatibility  with	 CMake	versions prior to 3.0, one may specify
       this generator using the	name "Visual Studio 11"	without	the year  com-
       ponent.

   Project Types
       Only  Visual  C++  and  C#  projects  may be generated.	Other types of
       projects	(JavaScript, Database, Website,	etc.) are not supported.

   Platform Selection
       The default target platform name	(architecture) is Win32.

       The CMAKE_GENERATOR_PLATFORM variable  may  be  set,  perhaps  via  the
       cmake(1)	 -A  option, to	specify	a target platform name (architecture).
       For example:

       o cmake -G "Visual Studio 11 2012" -A Win32

       o cmake -G "Visual Studio 11 2012" -A x64

       o cmake -G "Visual Studio 11 2012" -A ARM

       o cmake -G "Visual Studio 11 2012" -A  <WinCE-SDK>  (Specify  a	target
	 platform matching a Windows CE	SDK name.)

       For  compatibility  with	CMake versions prior to	3.1, one may specify a
       target platform name optionally at the end of the generator name.  This
       is supported only for:

       Visual Studio 11	2012 Win64
	      Specify target platform x64.

       Visual Studio 11	2012 ARM
	      Specify target platform ARM.

       Visual Studio 11	2012 <WinCE-SDK>
	      Specify target platform matching a Windows CE SDK	name.

   Toolset Selection
       The  v110  toolset that comes with Visual Studio	11 2012	is selected by
       default.	 The CMAKE_GENERATOR_TOOLSET option may	be  set,  perhaps  via
       the cmake(1) -T option, to specify another toolset.

   Visual Studio 12 2013
       Generates Visual	Studio 12 (VS 2013) project files.

       For  compatibility  with	 CMake	versions prior to 3.0, one may specify
       this generator using the	name "Visual Studio 12"	without	the year  com-
       ponent.

   Project Types
       Only  Visual  C++  and  C#  projects  may be generated.	Other types of
       projects	(JavaScript, Powershell, Python, etc.) are not supported.

   Platform Selection
       The default target platform name	(architecture) is Win32.

       The CMAKE_GENERATOR_PLATFORM variable  may  be  set,  perhaps  via  the
       cmake(1)	 -A  option, to	specify	a target platform name (architecture).
       For example:

       o cmake -G "Visual Studio 12 2013" -A Win32

       o cmake -G "Visual Studio 12 2013" -A x64

       o cmake -G "Visual Studio 12 2013" -A ARM

       For compatibility with CMake versions prior to 3.1, one may  specify  a
       target platform name optionally at the end of the generator name.  This
       is supported only for:

       Visual Studio 12	2013 Win64
	      Specify target platform x64.

       Visual Studio 12	2013 ARM
	      Specify target platform ARM.

   Toolset Selection
       The v120	toolset	that comes with	Visual Studio 12 2013 is  selected  by
       default.	  The  CMAKE_GENERATOR_TOOLSET	option may be set, perhaps via
       the cmake(1) -T option, to specify another toolset.

       For each	toolset	that comes with	this version of	Visual	Studio,	 there
       are  variants  that are themselves compiled for 32-bit (x86) and	64-bit
       (x64) hosts (independent	of the architecture they target).  By  default
       this  generator uses the	32-bit variant even on a 64-bit	host.  One may
       explicitly request use of either	the 32-bit or  64-bit  host  tools  by
       adding  either  host=x86	or host=x64 to the toolset specification.  See
       the CMAKE_GENERATOR_TOOLSET variable for	details.

   Visual Studio 14 2015
       Generates Visual	Studio 14 (VS 2015) project files.

   Project Types
       Only Visual C++ and C# projects	may  be	 generated.   Other  types  of
       projects	(JavaScript, Powershell, Python, etc.) are not supported.

   Platform Selection
       The default target platform name	(architecture) is Win32.

       The  CMAKE_GENERATOR_PLATFORM  variable	may  be	 set,  perhaps via the
       cmake(1)	-A option, to specify a	target platform	 name  (architecture).
       For example:

       o cmake -G "Visual Studio 14 2015" -A Win32

       o cmake -G "Visual Studio 14 2015" -A x64

       o cmake -G "Visual Studio 14 2015" -A ARM

       For  compatibility  with	CMake versions prior to	3.1, one may specify a
       target platform name optionally at the end of the generator name.  This
       is supported only for:

       Visual Studio 14	2015 Win64
	      Specify target platform x64.

       Visual Studio 14	2015 ARM
	      Specify target platform ARM.

   Toolset Selection
       The  v140  toolset that comes with Visual Studio	14 2015	is selected by
       default.	 The CMAKE_GENERATOR_TOOLSET option may	be  set,  perhaps  via
       the cmake(1) -T option, to specify another toolset.

       For  each  toolset that comes with this version of Visual Studio, there
       are variants that are themselves	compiled for 32-bit (x86)  and	64-bit
       (x64)  hosts (independent of the	architecture they target).  By default
       this generator uses the 32-bit variant even on a	64-bit host.  One  may
       explicitly  request  use	 of  either the	32-bit or 64-bit host tools by
       adding either host=x86 or host=x64 to the toolset  specification.   See
       the CMAKE_GENERATOR_TOOLSET variable for	details.

   Visual Studio 15 2017
       Generates Visual	Studio 15 (VS 2017) project files.

   Project Types
       Only  Visual  C++  and  C#  projects  may be generated.	Other types of
       projects	(JavaScript, Powershell, Python, etc.) are not supported.

   Instance Selection
       VS 2017 supports	multiple  installations	 on  the  same	machine.   The
       CMAKE_GENERATOR_INSTANCE	 variable may be set as	a cache	entry contain-
       ing the absolute	path to	a Visual Studio	instance.  If the value	is not
       specified explicitly by the user	or a toolchain file, CMake queries the
       Visual Studio Installer to locate VS instances, chooses one,  and  sets
       the variable as a cache entry to	hold the value persistently.

       When CMake first	chooses	an instance, if	the VS150COMNTOOLS environment
       variable	is set and points to the Common7/Tools directory within	one of
       the instances, that instance will be used.  Otherwise, if more than one
       instance	is installed we	do not define which one	is chosen by default.

   Platform Selection
       The default target platform name	(architecture) is Win32.

       The CMAKE_GENERATOR_PLATFORM variable  may  be  set,  perhaps  via  the
       cmake(1)	 -A  option, to	specify	a target platform name (architecture).
       For example:

       o cmake -G "Visual Studio 15 2017" -A Win32

       o cmake -G "Visual Studio 15 2017" -A x64

       o cmake -G "Visual Studio 15 2017" -A ARM

       o cmake -G "Visual Studio 15 2017" -A ARM64

       For compatibility with CMake versions prior to 3.1, one may  specify  a
       target platform name optionally at the end of the generator name.  This
       is supported only for:

       Visual Studio 15	2017 Win64
	      Specify target platform x64.

       Visual Studio 15	2017 ARM
	      Specify target platform ARM.

   Toolset Selection
       The v141	toolset	that comes with	Visual Studio 15 2017 is  selected  by
       default.	  The  CMAKE_GENERATOR_TOOLSET	option may be set, perhaps via
       the cmake(1) -T option, to specify another toolset.

       For each	toolset	that comes with	this version of	Visual	Studio,	 there
       are  variants  that are themselves compiled for 32-bit (x86) and	64-bit
       (x64) hosts (independent	of the architecture they target).  By  default
       this  generator uses the	32-bit variant even on a 64-bit	host.  One may
       explicitly request use of either	the 32-bit or  64-bit  host  tools  by
       adding  either  host=x86	or host=x64 to the toolset specification.  See
       the CMAKE_GENERATOR_TOOLSET variable for	details.

   Visual Studio 16 2019
       Generates Visual	Studio 16 (VS 2019) project files.

   Project Types
       Only Visual C++ and C# projects	may  be	 generated.   Other  types  of
       projects	(JavaScript, Powershell, Python, etc.) are not supported.

   Instance Selection
       VS  2019	 supports  multiple  installations  on	the same machine.  The
       CMAKE_GENERATOR_INSTANCE	variable may be	set as a cache entry  contain-
       ing the absolute	path to	a Visual Studio	instance.  If the value	is not
       specified explicitly by the user	or a toolchain file, CMake queries the
       Visual  Studio  Installer to locate VS instances, chooses one, and sets
       the variable as a cache entry to	hold the value persistently.

       When CMake first	chooses	an instance, if	the VS160COMNTOOLS environment
       variable	is set and points to the Common7/Tools directory within	one of
       the instances, that instance will be used.  Otherwise, if more than one
       instance	is installed we	do not define which one	is chosen by default.

   Platform Selection
       The default target platform name	(architecture) is that of the host and
       is provided in the CMAKE_VS_PLATFORM_NAME_DEFAULT variable.

       The CMAKE_GENERATOR_PLATFORM variable  may  be  set,  perhaps  via  the
       cmake(1)	 -A  option, to	specify	a target platform name (architecture).
       For example:

       o cmake -G "Visual Studio 16 2019" -A Win32

       o cmake -G "Visual Studio 16 2019" -A x64

       o cmake -G "Visual Studio 16 2019" -A ARM

       o cmake -G "Visual Studio 16 2019" -A ARM64

   Toolset Selection
       The v142	toolset	that comes with	Visual Studio 16 2019 is  selected  by
       default.	  The  CMAKE_GENERATOR_TOOLSET	option may be set, perhaps via
       the cmake(1) -T option, to specify another toolset.

       For each	toolset	that comes with	this version of	Visual	Studio,	 there
       are  variants  that are themselves compiled for 32-bit (x86) and	64-bit
       (x64) hosts (independent	of the architecture they target).  By  default
       this  generator	uses  the  64-bit  variant on x64 hosts	and the	32-bit
       variant otherwise.  One may explicitly request use of either the	32-bit
       or  64-bit  host	 tools	by  adding  either host=x86 or host=x64	to the
       toolset specification.  See the	CMAKE_GENERATOR_TOOLSET	 variable  for
       details.

   Other Generators
   Green Hills MULTI
       Generates    Green    Hills    MULTI   project	files	(experimental,
       work-in-progress).

       The buildsystem has predetermined build-configuration settings that can
       be controlled via the CMAKE_BUILD_TYPE variable.

       Customizations that are used to pick toolset and	target system:

       The  -A	<arch>	can  be	 supplied for setting the target architecture.
       <arch> usually is one of	arm, ppc, 86, etcetera.	 If the	target	archi-
       tecture	is  not	specified then the default architecture	of arm will be
       used.

       The -T <toolset>	option can be used to set the  directory  location  of
       the  toolset.   Both  absolute  and  relative paths are valid. Relative
       paths use GHS_TOOLSET_ROOT as the root. If the toolset is not specified
       then the	latest toolset found in	GHS_TOOLSET_ROOT will be used.

       Cache  variables	that are used for toolset and target system customiza-
       tion:

       o GHS_TARGET_PLATFORM
	 Defaults to integrity.
	 Usual values are integrity, threadx, uvelosity, velosity,
	 vxworks, standalone.

       o GHS_PRIMARY_TARGET
	 Sets primaryTarget entry in project file.
	 Defaults to <arch>_<GHS_TARGET_PLATFORM>.tgt.

       o GHS_TOOLSET_ROOT
	 Root path for toolset searches.
	 Defaults to C:/ghs in Windows or /usr/ghs in Linux.

       o GHS_OS_ROOT
	 Root path for RTOS searches.
	 Defaults to C:/ghs in Windows or /usr/ghs in Linux.

       o GHS_OS_DIR and	GHS_OS_DIR_OPTION
	 Sets -os_dir entry in project file.
	 Defaults to latest platform OS	installation at	GHS_OS_ROOT.  Set this value if
	 a specific RTOS is to be used.
	 GHS_OS_DIR_OPTION default value is -os_dir.

       o GHS_BSP_NAME
	 Sets -bsp entry in project file.
	 Defaults to sim<arch> for integrity platforms.

       Customizations are available through the	following cache	variables:

       o GHS_CUSTOMIZATION

       o GHS_GPJ_MACROS

       The following properties	are available:

       o GHS_INTEGRITY_APP

       o GHS_NO_SOURCE_GROUP_FILE

       NOTE:
	  This generator is deemed experimental	as  of	CMake  3.18.2  and  is
	  still	 a work	in progress.  Future versions of CMake may make	break-
	  ing changes as the generator matures.

   Xcode
       Generate	Xcode project files.

       This supports Xcode 5.0 and above.

   Toolset Selection
       By default Xcode	is allowed to select its own default  toolchain.   The
       CMAKE_GENERATOR_TOOLSET	option may be set, perhaps via the cmake(1) -T
       option, to specify another toolset.

EXTRA GENERATORS
       Some of the CMake Generators listed in the cmake(1)  command-line  tool
       --help  output may have variants	that specify an	extra generator	for an
       auxiliary IDE tool.  Such generator names have the form	<extra-genera-
       tor>  -	<main-generator>.  The following extra generators are known to
       CMake.

   CodeBlocks
       Generates CodeBlocks project files.

       Project files for CodeBlocks will be created in the top	directory  and
       in every	subdirectory which features a CMakeLists.txt file containing a
       project() call.	Additionally a hierarchy  of  makefiles	 is  generated
       into the	build tree.  The CMAKE_CODEBLOCKS_EXCLUDE_EXTERNAL_FILES vari-
       able may	be set to ON to	exclude	any files which	are located outside of
       the project root	directory.  The	appropriate make program can build the
       project through the default all target.	An install target is also pro-
       vided.

       This "extra" generator may be specified as:

       CodeBlocks - MinGW Makefiles
	      Generate with MinGW Makefiles.

       CodeBlocks - NMake Makefiles
	      Generate with NMake Makefiles.

       CodeBlocks - NMake Makefiles JOM
	      Generate with NMake Makefiles JOM.

       CodeBlocks - Ninja
	      Generate with Ninja.

       CodeBlocks - Unix Makefiles
	      Generate with Unix Makefiles.

   CodeLite
       Generates CodeLite project files.

       Project	files for CodeLite will	be created in the top directory	and in
       every subdirectory which	features a CMakeLists.txt  file	 containing  a
       project()  call.	 The CMAKE_CODELITE_USE_TARGETS	variable may be	set to
       ON to change the	default	behavior from projects to targets as the basis
       for  project files.  The	appropriate make program can build the project
       through the default all target.	An install target is also provided.

       This "extra" generator may be specified as:

       CodeLite	- MinGW	Makefiles
	      Generate with MinGW Makefiles.

       CodeLite	- NMake	Makefiles
	      Generate with NMake Makefiles.

       CodeLite	- Ninja
	      Generate with Ninja.

       CodeLite	- Unix Makefiles
	      Generate with Unix Makefiles.

   Eclipse CDT4
       Generates Eclipse CDT 4.0 project files.

       Project files for Eclipse will be created in the	top directory.	In out
       of  source  builds, a linked resource to	the top	level source directory
       will be created.	 Additionally a	hierarchy of  makefiles	 is  generated
       into  the  build	 tree.	 The  appropriate  make	 program can build the
       project through the default all target.	An install target is also pro-
       vided.

       This "extra" generator may be specified as:

       Eclipse CDT4 - MinGW Makefiles
	      Generate with MinGW Makefiles.

       Eclipse CDT4 - NMake Makefiles
	      Generate with NMake Makefiles.

       Eclipse CDT4 - Ninja
	      Generate with Ninja.

       Eclipse CDT4 - Unix Makefiles
	      Generate with Unix Makefiles.

   Kate
       Generates Kate project files.

       A project file for Kate will be created in the top directory in the top
       level build directory.  To use it in Kate, the Project plugin  must  be
       enabled.	  The  project	file is	loaded in Kate by opening the Project-
       Name.kateproject	file in	the editor.  If	the Kate Build-plugin  is  en-
       abled, all targets generated by CMake are available for building.

       This "extra" generator may be specified as:

       Kate - MinGW Makefiles
	      Generate with MinGW Makefiles.

       Kate - NMake Makefiles
	      Generate with NMake Makefiles.

       Kate - Ninja
	      Generate with Ninja.

       Kate - Unix Makefiles
	      Generate with Unix Makefiles.

   Sublime Text	2
       Generates Sublime Text 2	project	files.

       Project	files  for Sublime Text	2 will be created in the top directory
       and in every subdirectory which features	a CMakeLists.txt file contain-
       ing  a  project()  call.	 Additionally Makefiles	(or build.ninja	files)
       are generated into the build tree.  The appropriate  make  program  can
       build the project through the default all target.  An install target is
       also provided.

       This "extra" generator may be specified as:

       Sublime Text 2 -	MinGW Makefiles
	      Generate with MinGW Makefiles.

       Sublime Text 2 -	NMake Makefiles
	      Generate with NMake Makefiles.

       Sublime Text 2 -	Ninja
	      Generate with Ninja.

       Sublime Text 2 -	Unix Makefiles
	      Generate with Unix Makefiles.

COPYRIGHT
       2000-2020 Kitware, Inc. and Contributors

3.18.2				 Aug 27, 2020		   CMAKE-GENERATORS(7)

NAME | INTRODUCTION | CMAKE GENERATORS | EXTRA GENERATORS | COPYRIGHT

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=cmake-generators&sektion=7&manpath=FreeBSD+12.2-RELEASE+and+Ports>

home | help