All systems are go: CLion 2017.2 roadmap


It’s been a week since we released our first big update this year – CLion 2017.1. We’d like to thank you all for your warm welcome and useful feedback. If you haven’t tried it yet, do it today! There are lots of goodies like C++14 and some C++17, disassembly view, Microsoft Visual C++ compiler, Catch and many more.

All systems are go, and we’re moving on to 2017.2.

Special thanks

To follow a good tradition, let us first thank those who helped us in the early stages as we ran the 2017.1 Early Access Program. We’re rewarding the following contributors whose input was the most valuable in this release cycle:

  • Andrew Somerville (Twitter handle: catskul)
  • Rohan Joyce (YouTrack handle: rfjoyce)
  • Jean-Marc Bourguet (YouTrack handle:
  • Matt Godbolt (YouTrack handle: mattgodbolt)

In appreciation of your efforts, we present you with a free 1-year subscription for CLion (to extend your current subscription or get a new one). Each of you will receive a personal email with details on how to claim your license. (If for some reason you do not get any email from us within a week, ping us here in the comments.)

What you can expect from CLion 2017.2

After analyzing the feedback and the current state of CLion, we’ve decided to dedicate the upcoming release to various fixes, cleanups and improvements to current functionality. That doesn’t mean nothing new could finally join the release, but our focus will be shifted more into this direction.

Note: The following is a preliminary plan; we cannot guarantee that all of the features listed below will be included in CLion 2017.2.
  • C++ support
    • Continue with C++17. Check the list of supported language features in our webhelp
    • Fix false-positives in code analysis, which are mostly caused by incorrect code resolve
    • Modernize code transformation actions (like code generation or some intentions) so that modern C++ standards are in use
  • Microsoft Visual C++ compiler support
    Started as an experimental feature in 2017.1, this will be evaluated and get wider adoption in CLion:

    • Microsoft language extensions support
    • Support for precompiled headers (that currently works for GCC and clang)
  • Debugger
    • Continue working on the disassembly view in debugger:
      • force step into action (CPP-8978) to avoid jumping into the disassembly when not expected
      • disassembly view for LLDB (CPP-8908)
      • disassemble on demand (CPP-9091) to cover cases when the sources are available, but the disassembly view is still required
    • Hex formatting for numerical variables (OC-2305)
    • Debug as root (CPP-7224)
  • Project model
    This is still going to be CMake. Please see the section below explaining our plans regarding other build systems. In 2017.2 we will mainly address the following:

    • Make toolchains settings configurable per project / per configuration (not per IDE as it is now). This will cover environment, CMake settings, compiler, debugger, etc. (CPP-8893)
    • MSYS support (CPP-2275)
  • Performance
    Unfortunately it’s hard to promise something specific here, but we 100% sure to dedicate some additional time to this task. Our current plan is not only to continue working on investigating user-submitted snapshots, but also to implement a set of index and other optimizations.
  • Others
    Other planned tasks include fixes related to unit testing (for both Google Test and Catch), macro formatting, fixes for some current issues with the Python support plugin, and more.

Looks like we’ve packed quite a lot here, so let’s see what we can really achieve until July or August, which is when the actual release is planned.

No makefiles?

Sorting the tickets in our tracker by votes, we find some clear winners – Makefiles and remote toolchain support. As you’ve been asking about our plans on these, we’ll address them here to make our planning process clearer and explain our choices.

The immediate answer, as you can see from the roadmap, is No. We are not planning any of these task for 2017.2. However, the eventual answer is Yes… after we resolve some other issues.

Let’s talk about Makefiles. It all boils down to the experience we would like to offer to the users of CLion. Originally we made the choice to use CMake as a main project model and we believe it was the right decision. Thanks to all the help and support from our community, we’ve made huge progress since then. But we are not yet satisfied with the level of support and usability of CMake integration and would like to improve it, before we move further and add support for Makefiles and other build systems.

The major planned CMake improvements are:

  • Ninja generator support,
  • configuring CMake defaults,
  • canceling CMake generation process.

This will also be considered for 2017.2 and 2017.3.

Also, since one of CLion’s main strengths is being a cross-platform IDE, we would like to offer Windows support on par with Linux/macOS. That means CLion needs to work with Microsoft Visual C++ compiler as effectively as it works with GCC or Clang. We already started working on this, and will continue to do so in the next release cycle.

Implementing Makefiles support will require additional work around the project model and indexing. Since Makefiles do not directly list headers, first we need to find a solution for problems related to non-project headers (CPP-263, CPP-270).

These are the main tasks we would like to finish before implementing Makefiles support, though there might be additional smaller ones. Since we cannot predict how long they will take, we can’t give you an ETA. But please rest assured that Makefiles is on our radar and we believe it will be an important addition for CLion as a cross-platform C/C++ IDE.

This is it! Stay tuned and don’t miss the EAP launch for 2017.2.

Your CLion Team

The Drive to Develop

image description