Alternatives to CMake logo

Alternatives to CMake

Make, Bazel, Apache Maven, Gradle, and Sonatype Nexus are the most popular alternatives and competitors to CMake.
826
235
+ 1
1

What is CMake and what are its top alternatives?

It is used to control the software compilation process using simple platform and compiler independent configuration files, and generate native makefiles and workspaces that can be used in the compiler environment of the user's choice.
CMake is a tool in the Java Build Tools category of a tech stack.

Top Alternatives to CMake

  • Make
    Make

    The GNU Compiler Collection and GNU Toolchain (Binutils, GDB, GLIBC)

  • Bazel
    Bazel

    Bazel is a build tool that builds code quickly and reliably. It is used to build the majority of Google's software, and thus it has been designed to handle build problems present in Google's development environment. ...

  • Apache Maven
    Apache Maven

    Maven allows a project to build using its project object model (POM) and a set of plugins that are shared by all projects using Maven, providing a uniform build system. Once you familiarize yourself with how one Maven project builds you automatically know how all Maven projects build saving you immense amounts of time when trying to navigate many projects. ...

  • Gradle
    Gradle

    Gradle is a build tool with a focus on build automation and support for multi-language development. If you are building, testing, publishing, and deploying software on any platform, Gradle offers a flexible model that can support the entire development lifecycle from compiling and packaging code to publishing web sites. ...

  • Sonatype Nexus
    Sonatype Nexus

    It is an open source repository that supports many artifact formats, including Docker, Java™ and npm. With the Nexus tool integration, pipelines in your toolchain can publish and retrieve versioned apps and their dependencies ...

  • JFrog Artifactory
    JFrog Artifactory

    It integrates with your existing ecosystem supporting end-to-end binary management that overcomes the complexity of working with different software package management systems, and provides consistency to your CI/CD workflow. ...

  • Apache Ant
    Apache Ant

    Ant is a Java-based build tool. In theory, it is kind of like Make, without Make's wrinkles and with the full portability of pure Java code. ...

  • SBT
    SBT

    It is similar to Java's Maven and Ant. Its main features are: Native support for compiling Scala code and integrating with many Scala test frameworks. ...

CMake alternatives & related posts

Make logo

Make

242
111
1
The GNU Compiler Collection and GNU Toolchain (Binutils, GDB, GLIBC)
242
111
+ 1
1
PROS OF MAKE
  • 1
    No-nonsense approach to builds. Just works
  • 0
    One-line Execution
CONS OF MAKE
    Be the first to leave a con

    related Make posts

    Bazel logo

    Bazel

    236
    480
    124
    Build and test software of any size, quickly and reliably
    236
    480
    + 1
    124
    PROS OF BAZEL
    • 27
      Fast
    • 19
      Deterministic incremental builds
    • 16
      Correct
    • 15
      Multi-language
    • 13
      Enforces declared inputs/outputs
    • 9
      High-level build language
    • 8
      Scalable
    • 5
      Multi-platform support
    • 4
      Sandboxing
    • 3
      Dependency management
    • 2
      Flexible
    • 2
      Windows Support
    • 1
      Android Studio integration
    CONS OF BAZEL
    • 3
      No Windows Support
    • 2
      Bad IntelliJ support
    • 1
      Poor windows support for some languages
    • 1
      Constant breaking changes
    • 1
      Learning Curve
    • 1
      Lack of Documentation

    related Bazel posts

    Joshua Dean Küpper
    CEO at Scrayos UG (haftungsbeschränkt) · | 2 upvotes · 269.6K views

    All Java-Projects are compiled using Apache Maven. We prefer it over Apache Ant and Gradle as it combines lightweightness with feature-richness and offers basically all we can imagine from a software project-management tool and more. We're open however to re-evaluate this decision in favor of Gradle or Bazel in the future if we feel like we're missing out on anything.

    See more
    Apache Maven logo

    Apache Maven

    2.4K
    1.5K
    413
    Apache build manager for Java projects.
    2.4K
    1.5K
    + 1
    413
    PROS OF APACHE MAVEN
    • 136
      Dependency management
    • 71
      Necessary evil
    • 60
      I’d rather code my app, not my build
    • 48
      Publishing packaged artifacts
    • 43
      Convention over configuration
    • 18
      Modularisation
    • 11
      Consistency across builds
    • 6
      Prevents overengineering using scripting
    • 4
      Runs Tests
    • 4
      Lot of cool plugins
    • 3
      Extensible
    • 2
      Hard to customize
    • 2
      Runs on Linux
    • 1
      Runs on OS X
    • 1
      Slow incremental build
    • 1
      Inconsistent buillds
    • 1
      Undeterminisc
    • 1
      Good IDE tooling
    CONS OF APACHE MAVEN
    • 6
      Complex
    • 1
      Inconsistent buillds
    • 0
      Not many plugin-alternatives

    related Apache Maven posts

    Tymoteusz Paul
    Devops guy at X20X Development LTD · | 23 upvotes · 5.2M views

    Often enough I have to explain my way of going about setting up a CI/CD pipeline with multiple deployment platforms. Since I am a bit tired of yapping the same every single time, I've decided to write it up and share with the world this way, and send people to read it instead ;). I will explain it on "live-example" of how the Rome got built, basing that current methodology exists only of readme.md and wishes of good luck (as it usually is ;)).

    It always starts with an app, whatever it may be and reading the readmes available while Vagrant and VirtualBox is installing and updating. Following that is the first hurdle to go over - convert all the instruction/scripts into Ansible playbook(s), and only stopping when doing a clear vagrant up or vagrant reload we will have a fully working environment. As our Vagrant environment is now functional, it's time to break it! This is the moment to look for how things can be done better (too rigid/too lose versioning? Sloppy environment setup?) and replace them with the right way to do stuff, one that won't bite us in the backside. This is the point, and the best opportunity, to upcycle the existing way of doing dev environment to produce a proper, production-grade product.

    I should probably digress here for a moment and explain why. I firmly believe that the way you deploy production is the same way you should deploy develop, shy of few debugging-friendly setting. This way you avoid the discrepancy between how production work vs how development works, which almost always causes major pains in the back of the neck, and with use of proper tools should mean no more work for the developers. That's why we start with Vagrant as developer boxes should be as easy as vagrant up, but the meat of our product lies in Ansible which will do meat of the work and can be applied to almost anything: AWS, bare metal, docker, LXC, in open net, behind vpn - you name it.

    We must also give proper consideration to monitoring and logging hoovering at this point. My generic answer here is to grab Elasticsearch, Kibana, and Logstash. While for different use cases there may be better solutions, this one is well battle-tested, performs reasonably and is very easy to scale both vertically (within some limits) and horizontally. Logstash rules are easy to write and are well supported in maintenance through Ansible, which as I've mentioned earlier, are at the very core of things, and creating triggers/reports and alerts based on Elastic and Kibana is generally a breeze, including some quite complex aggregations.

    If we are happy with the state of the Ansible it's time to move on and put all those roles and playbooks to work. Namely, we need something to manage our CI/CD pipelines. For me, the choice is obvious: TeamCity. It's modern, robust and unlike most of the light-weight alternatives, it's transparent. What I mean by that is that it doesn't tell you how to do things, doesn't limit your ways to deploy, or test, or package for that matter. Instead, it provides a developer-friendly and rich playground for your pipelines. You can do most the same with Jenkins, but it has a quite dated look and feel to it, while also missing some key functionality that must be brought in via plugins (like quality REST API which comes built-in with TeamCity). It also comes with all the common-handy plugins like Slack or Apache Maven integration.

    The exact flow between CI and CD varies too greatly from one application to another to describe, so I will outline a few rules that guide me in it: 1. Make build steps as small as possible. This way when something breaks, we know exactly where, without needing to dig and root around. 2. All security credentials besides development environment must be sources from individual Vault instances. Keys to those containers should exist only on the CI/CD box and accessible by a few people (the less the better). This is pretty self-explanatory, as anything besides dev may contain sensitive data and, at times, be public-facing. Because of that appropriate security must be present. TeamCity shines in this department with excellent secrets-management. 3. Every part of the build chain shall consume and produce artifacts. If it creates nothing, it likely shouldn't be its own build. This way if any issue shows up with any environment or version, all developer has to do it is grab appropriate artifacts to reproduce the issue locally. 4. Deployment builds should be directly tied to specific Git branches/tags. This enables much easier tracking of what caused an issue, including automated identifying and tagging the author (nothing like automated regression testing!).

    Speaking of deployments, I generally try to keep it simple but also with a close eye on the wallet. Because of that, I am more than happy with AWS or another cloud provider, but also constantly peeking at the loads and do we get the value of what we are paying for. Often enough the pattern of use is not constantly erratic, but rather has a firm baseline which could be migrated away from the cloud and into bare metal boxes. That is another part where this approach strongly triumphs over the common Docker and CircleCI setup, where you are very much tied in to use cloud providers and getting out is expensive. Here to embrace bare-metal hosting all you need is a help of some container-based self-hosting software, my personal preference is with Proxmox and LXC. Following that all you must write are ansible scripts to manage hardware of Proxmox, similar way as you do for Amazon EC2 (ansible supports both greatly) and you are good to go. One does not exclude another, quite the opposite, as they can live in great synergy and cut your costs dramatically (the heavier your base load, the bigger the savings) while providing production-grade resiliency.

    See more
    Shared insights
    on
    Apache MavenApache MavenGradleGradle
    at

    We use Apache Maven because it is a standard. Gradle is very good alternative, but Gradle doesn't provide any advantage for our project. Gradle is slower (without running daemon), need more resources and a learning curve is quite big. Our project can not use a great flexibility of Gradle. On the other hand, Maven is well-know tool integrated in many IDEs, Dockers and so on.

    See more
    Gradle logo

    Gradle

    11.3K
    7.5K
    254
    A powerful build system for the JVM
    11.3K
    7.5K
    + 1
    254
    PROS OF GRADLE
    • 110
      Flexibility
    • 51
      Easy to use
    • 47
      Groovy dsl
    • 22
      Slow build time
    • 10
      Crazy memory leaks
    • 8
      Fast incremental builds
    • 5
      Kotlin DSL
    • 1
      Windows Support
    CONS OF GRADLE
    • 7
      Inactionnable documentation
    • 6
      It is just the mess of Ant++
    • 4
      Hard to decide: ten or more ways to achieve one goal
    • 2
      Bad Eclipse tooling
    • 2
      Dependency on groovy

    related Gradle posts

    Shared insights
    on
    Apache MavenApache MavenGradleGradle
    at

    We use Apache Maven because it is a standard. Gradle is very good alternative, but Gradle doesn't provide any advantage for our project. Gradle is slower (without running daemon), need more resources and a learning curve is quite big. Our project can not use a great flexibility of Gradle. On the other hand, Maven is well-know tool integrated in many IDEs, Dockers and so on.

    See more
    Application & Data

    Java JavaScript Node.js nginx Ubuntu MongoDB Amazon EC2 Redis Amazon S3 AWS Lambda RabbitMQ Kafka MySQL Spring Boot Dropwizard Vue.js Flutter

    Utilities

    Google Analytics Elasticsearch Amazon Route 53

    DevOps

    GitHub Docker Webpack CircleCI Jenkins Travis CI Gradle Apache Maven

    Cooperation Tools

    Jira notion.so Trello

    See more
    Sonatype Nexus logo

    Sonatype Nexus

    483
    323
    0
    organize, store, and distribute software components
    483
    323
    + 1
    0
    PROS OF SONATYPE NEXUS
      Be the first to leave a pro
      CONS OF SONATYPE NEXUS
        Be the first to leave a con

        related Sonatype Nexus posts

        Joshua Dean Küpper
        CEO at Scrayos UG (haftungsbeschränkt) · | 10 upvotes · 212.4K views

        We use Sonatype Nexus to store our closed-source java libraries to simplify our deployment and dependency-management. While there are many alternatives, most of them are expensive ( GitLab Enterprise ), monilithic ( JFrog Artifactory ) or only offer SaaS-licences. We preferred the on-premise approach of Nexus and therefore decided to use it.

        We exclusively use the Maven-capabilities and are glad that the modular design of Nexus allows us to run it very lightweight.

        See more
        Bryan Dady
        SRE Manager at Subsplash · | 3 upvotes · 298.8K views

        I'm beginning to research the right way to better integrate how we achieve SCA / shift-left / SecureDevOps / secure software supply chain. If you use or have evaluated WhiteSource, Snyk, Sonatype Nexus, SonarQube or similar, I would very much appreciate your perspective on strengths and weaknesses and how you selected your ultimate solution. I want to integrate with GitLab CI.

        See more
        JFrog Artifactory logo

        JFrog Artifactory

        299
        313
        0
        Enterprise Universal Repository Manager
        299
        313
        + 1
        0
        PROS OF JFROG ARTIFACTORY
          Be the first to leave a pro
          CONS OF JFROG ARTIFACTORY
            Be the first to leave a con

            related JFrog Artifactory posts

            Joshua Dean Küpper
            CEO at Scrayos UG (haftungsbeschränkt) · | 10 upvotes · 212.4K views

            We use Sonatype Nexus to store our closed-source java libraries to simplify our deployment and dependency-management. While there are many alternatives, most of them are expensive ( GitLab Enterprise ), monilithic ( JFrog Artifactory ) or only offer SaaS-licences. We preferred the on-premise approach of Nexus and therefore decided to use it.

            We exclusively use the Maven-capabilities and are glad that the modular design of Nexus allows us to run it very lightweight.

            See more

            Whenever Qualys scan finds out software vulnerability, say for example Java SDK or any software version that has a potential vulnerability, we search the web to find out the solution and usually install a later version or patch downloading from the web. The problem is, as we are downloading it from web and there are a number of servers where we patch and as an ultimate outcome different people downloads different version and so forth. So I want to create a repository for such binaries so that we use the same patch for all servers.

            When I was thinking about the repo, obviously first thought came as GitHub.. But then I realized, it is for code version control and collaboration, not for the packaged software. The other option I am thinking is JFrog Artifactory which stores the binaries and the package software.

            What is your recommendation?

            See more
            Apache Ant logo

            Apache Ant

            168
            142
            7
            Java based build tool
            168
            142
            + 1
            7
            PROS OF APACHE ANT
            • 4
              Flexible
            • 1
              Simple
            • 1
              Easy to learn
            • 1
              Easy to write own java-build-hooks
            CONS OF APACHE ANT
            • 1
              Slow
            • 1
              Old and not widely used anymore

            related Apache Ant posts

            Joshua Dean Küpper
            CEO at Scrayos UG (haftungsbeschränkt) · | 2 upvotes · 269.6K views

            All Java-Projects are compiled using Apache Maven. We prefer it over Apache Ant and Gradle as it combines lightweightness with feature-richness and offers basically all we can imagine from a software project-management tool and more. We're open however to re-evaluate this decision in favor of Gradle or Bazel in the future if we feel like we're missing out on anything.

            See more
            SBT logo

            SBT

            156
            102
            11
            An open source build tool for Scala and Java projects
            156
            102
            + 1
            11
            PROS OF SBT
            • 1
              Support for publishing artifacts in Maven, Ivy formats
            • 1
              Works across Windows, Linux and MacOS
            • 1
              Support for Zinc and BSP
            • 1
              No Breaking Changes
            • 1
              Best for Mono-Repo and Multi-Project builds
            • 1
              Preference option to build Mix Scala-Java Projects
            • 1
              IntelliJ support
            • 1
              Continuous compilation
            • 1
              Flexible
            • 1
              Dependency manageemnt
            • 1
              Incremental Builds
            CONS OF SBT
            • 1
              Learning Curve is a bit steep

            related SBT posts

            Shared insights
            on
            ScalaScalaSBTSBTGradleGradle

            What are the advantages of using Gradle over SBT for Scala projects? Currently, I am doing POC between Gradle and SBT.

            See more