Home Explore Help
Sign In
Apq
/
CMake
mirror of https://github.com/Kitware/CMake.git
1
0
Fork 0
Files Issues 0 Wiki
Tree: bda5baa566
Branches Tags
CMake
/
Web
/
HTML
/
About.html

About.html 5.8 KB
History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115 
  1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    2. 

  2. 

  3. <html>
    4. 

  4. 

  5. <!--#include virtual="/CMake/HTML/Head.html"-->
    6. 

  6. 

  7. <body bgcolor="#FFFFFF" leftmargin=0 topmargin=0 text="black" link="#FFFFFF" 
    8. 

  8. vlink="#000000" alink="#000000">
    9. 

  9. 

  10. <!--#include virtual="/CMake/HTML/Table.html"-->
    11. 

  11. 

  12. <tr>
    13. 

  13. <!--#include virtual="/CMake/HTML/SideBar.html"-->
    14. 

  14. 

  15.     <td width="550" valign="top" bgcolor="#FFFFFF">
    16. 

  16.     <div align="left">
    17. 

  17. 

  18.     <font size=5>CMake </font> is an extensible, open-source system that
    19. 

  19.     manages the build process in an operating system and compiler independent
    20. 

  20.     manner. Unlike many cross-platform systems, CMake is designed to be used
    21. 

  21.     in conjunction with the native build environment. Simple configuration
    22. 

  22.     files placed in each source directory (called CMakeLists.txt files) are
    23. 

  23.     used to generate standard build files (e.g., makefiles on Unix and
    24. 

  24.     projects/workspaces in Windows MSVC) which are used in the usual
    25. 

  25.     way. CMake can compile source code, create libraries, generate wrappers,
    26. 

  26.     and build executables in arbitrary combinations. CMake supports in-place
    27. 

  27.     and out-of-place builds, and can therefore support multiple builds from a
    28. 

  28.     single source tree. CMake also supports static and dynamic library
    29. 

  29.     builds.  Another nice feature of CMake is that it generates a cache file
    30. 

  30.     that is designed to be used with a graphical editor. For example, when
    31. 

  31.     CMake runs, it locates include files, libraries, and executable, and may
    32. 

  32.     encounter optional build directives. This information is gathered into
    33. 

  33.     the cache, which may be changed by the user prior to the generation of
    34. 

  34.     the native build files. (The following figure is the CMake cache GUI in
    35. 

  35.     the Windows MSVC environment.)
    36. 

  36.     <div align="center">
    37. 

  37.     <img src="/CMake/Art/CMakeGUI.jpg" width=400 height=276 
    38. 

  38.     border=0 alt="">
    39. 

  39.     </div>
    40. 

  40.     <P>
    41. 

  41. 

  42.     CMake is designed to support complex directory hierarchies and
    43. 

  43.     applications dependent on several libraries. For example, CMake supports
    44. 

  44.     projects consisting of multiple toolkits (i.e., libraries), where each
    45. 

  45.     toolkit might contain several directories, and the application depends on
    46. 

  46.     the toolkits plus additional code. CMake can also handle situations where
    47. 

  47.     executables must be built in order to generate code that is then compiled
    48. 

  48.     and linked into a final application. Because CMake is open source, and has
    49. 

  49.     a simple, extensible design, CMake can be extended as necessary to support
    50. 

  50.     new features.
    51. 

  51.     <P>
    52. 

  52. 

  53.     Using CMake is simple. The build process is controlled by creating one or
    54. 

  54.     more CMakeLists.txt files in each directory (including subdirectories)
    55. 

  55.     that make up a project. Each CMakeLists.txt consists of one or more
    56. 

  56.     commands. Each command has the form COMMAND (args...) where COMMAND is
    57. 

  57.     the name of the command, and args is a white-space separated list of
    58. 

  58.     arguments. CMake provides many pre-defined commands, but if you need to,
    59. 

  59.     you can add your own commands. In addition, the advanced user can add
    60. 

  60.     other makefile generators for a particular compiler/OS combination.
    61. 

  61.     (While Unix and MSVC++ is supported currently, other developers are
    62. 

  62.     adding other compiler/OS support.) You may wish to study the
    63. 

  63.     <a href="/CMake/HTML/Examples.html">examples</a> page to see more
    64. 

  64.     details.
    65. 

  65. 

  66.     <h3>The Origins of CMake</h3> CMake was created in response to the need
    67. 

  67.     for a powerful, cross-platform build environment for the Insight
    68. 

  68.     Segmentation and Registration Toolkit (ITK) funded by NLM as part of the
    69. 

  69.     Visible Human Project. It was influenced by an earlier system called
    70. 

  70.     <b>pcmaker</b> created by Ken Martin and other developers to support the
    71. 

  71.     <a href="http://public.kitware.com/vtk.html">Visualization Toolkit
    72. 

  72.     (VTK)</a> open source 3D graphics and visualization system. To create
    73. 

  73.     CMake, Bill Hoffman at Kitware incorporated some key ideas from pcmaker,
    74. 

  74.     and  added many more of his own, with the thought to adopt some of the 
    75. 

  75.     functionality of the Unix
    76. 

  76.     <b>configure</b> tool. The initial CMake implementation was mid-2000,
    77. 

  77.     with acclerated development occuring in early 2001. Many improvements
    78. 

  78.     were due to the influences of other developers incorporating CMake into
    79. 

  79.     their own systems. For example, the 
    80. 

  80.     <a href="http://www.robots.ox.ac.uk/~vxl/">VXL</a> software community
    81. 

  81.     adopted CMake as their build environment, contributing many essential
    82. 

  82.     features. Brad King added several features in order to support the CABLE
    83. 

  83.     automated wrapping environment and 
    84. 

  84.     <a href="http://public.kitware.com/GCC_XML">GCC-XML</a>, and 
    85. 

  85.     GE Corporate R&D required support of their testing infrastructure 
    86. 

  86.     (the <a href="http://public.kitware.com/Insight/Testing/HTML/TestingResults/Dashboard/MostRecentResults-Nightly/Dashboard.html">quality dashboard</a>). 
    87. 

  87.     Other features were added to support the transition of VTK's
    88. 

  88.     build environment to CMake, and to support ParaView, a parallel
    89. 

  89.     visualization system to support the 
    90. 

  90.     <a href="http://www.acl.lanl.gov/">Advanced Computing Lab</a> at Los Alamos
    91. 

  91.     National Laboratory.
    92. 

  92. 

  93.     <h3>How Do I Learn CMake?</h3> CMake is a young and rapidly growing
    94. 

  94.     system. It has already seen extensive use in very large software systems
    95. 

  95.     such as VTK, VXL, and ITK, and is therefore, quite
    96. 

  96.     stable. Unfortuneately, the pace of development has outstripped the pace
    97. 

  97.     of documentation. As a result, the best way to learn about CMake is to
    98. 

  98.     study existing CMake installations, and to rely on the CMake mailing
    99. 

  99.     list. There is some existing documentation, but until later in 2001 the
    100. 

  100.     documentation should be treated with caution. Please go to the
    101. 

  101.     <a href="/CMake/HTML/Documentation.html">documentation</a> for more
    102. 

  102.     information. Also, see the <a href="/CMake/HTML/Examples.html">example</a>
    103. 

  103.     found here.
    104. 

  104.     </div>
    105. 

  105.     </td>
    106. 

  106. </tr>
    107. 

  107. 

  108. </table>
    109. 

  109. 

  110. </td>
    111. 

  111. </tr>
    112. 

  112. </table>
    113. 

  113. 

  114. </body>
    115. 

  115. </html>
    116.