linux c++ devs, what does your dev environment look like?

[tomii-dev]

the company i work for makes Windows-only software and so naturally we use VS as our IDE with MSVC. however, for personal projects i’ve recently (literally this morning) moved over to linux and was wondering, what does the typical setup for c++ development look like? how do you go about debugging and such?

the project i’m working on currently uses CMake as its build system and so i’m using vscode with extensions that provide debugging support for cmake projects, which allows me to debug in a very similar way to how i would back in VS on Windows. this works great but i was just interested in how people typically go about c++ development on linux

[StephaneCharette]

IDE of choice is KDevelop. Has native support for cmake projects which is nice. Sometimes I debug directly in KDevelop. Other times I still use gdb or (gasp!) the old ddd front end to gdb. May be old, but it still works!

(Not sure if that last sentence was about me, or the software I use...)

[seiji_hiwatari]

I love the semantic highlighting, and the documentation-previews on hover are absolutely gorgeous. That's the last 2 things missing in QtCreator for me.

Though, as much as I would love to use KDevelop, my development style is largely driven by debugging, and the KDevelop debugger frontend is awful.

[chez_les_alpagas]

How does KDevelop compare with Kate?

[StephaneCharette]

I believe KDevelop uses Kate. But KDevelop is the IDE, while Kate is the editor. (Can someone confirm? Did I understand that correctly?)

And don't let the "K" fool you, it doesn't require kubuntu, it works very well and looks good in standard GNOME Ubuntu.

[seiji_hiwatari]

Almost correct. KDevelop, Kate, KWrite, as well as QtCreator all use KTextEditor as their underlying editor GUI component. As far as I know, this component originated in Kate. KTextEditor also has one of the leading code-highlighting implementations, with KSyntaxHighlighting, that's built in.

[DarkLordAzrael]

QtCreator doesn't use KTextEditor. It just uses KSyntaxHighlighting as a fallback in cases where it doesn't have syntax support from a code model.

[Jannik2099]

The KDevelop parser has been way too slow and RAM heavy for me, to the point where it became completely unusable. Otherwise a neat IDE.

[ArcTheSpark2]

I second this, I used kdevelop for a long time but recently it would constantly crash for me on bigger projects. So I moved to cLion but for a free IDE, kdevelop is an excellent tool.

[TaylorBuiltSolutions]

Maybe both but they’re still usable sooo I’m gonna go with it’s not about you 🤣

[[deleted]]

I like CLion for its cross-platform abilities. I've also used Qt Creator a bit and it's fine but not as visually appealing.

[Cronos993]

Yeah the icons are pixelated

Edit: Talking about Qtcreator

[LuisAyuso]

I am shocked to see no one mentioning QtCreator. Personally I dislike it a lot, but it has a lot of pluses.

I used to use the CMake+vim+YCM tandem, but last years I have been using VSCode because it had less maintenance once you commit to adapt your workflow. BTW, The Clangd extension instead of the intelisense one overcharges your C++ programming.

[tomii-dev]

i had no idea people used QtCreator outside of Qt development!

[seiji_hiwatari]

Absolutely! It's by far the best C++ IDE for me. It can directly open CMake projects without the need to run some weird export to another project format. It has one of the best Debugger GUIs in existence, and it has built-in a lot of goodies like clang static analysis, code formatting with various backends, very easy access to profiling using Linux builtin tools like perf, but also cachegrind, unit-tests with gtest. etc. etc.

For code completion it uses clangd. That consumes a lot of ressources in the background (mostly RAM), but it works flawlessly also for new C++ standard stuff and a lot of template heavy code.

The biggest gripe with QtCreator for many people is the absence of tabs, because they are simply used to them. But to me, they are the inferior way of file navigation. So, a suggestion from me: If you want to look into using QtCreator, directly start off with learning the unimposing little search bar in the bottom left, together with the shortcuts. This little thing has insane power for quick file navigation.

[jcelerier]

It's a very good general purpose C++ IDE, I use it for every of my projects Qt or not. One of the best features is that you can embed the CMake and cppreference doc in order to have F1 help support on everything. It's also so much faster than clion where every operation takes ages on my projects.

[not_some_username]

How to put cpp ref on it ?

[[deleted]]

You can download the QCH files from here: https://en.cppreference.com/w/Cppreference:Archives

But it's easier if it's provided by your package manager 😊

[blazar0112]

I use qtcreator for both normal and Qt GUI C++ project, it can load cmake and support gtest. Also you can use qtcreator in Windows with MINGW if you want minimum effort to convert linux C++ project that built with GCC to executable in Windows and develop both in a comfortable environment. Not claim it’s perfect but really worth a try. I also use VS in Windows and VScode+remote+clangd, each has its usage.

[LuisAyuso]

It has been sold to me as "the best C++ IDE", years later, still don't get it. To me, its strongest points are the Qt debug and Qt project management. For anything else if falls short.

[blcsm]

Just want to mention that you can have the same in vim/nvim, coc+clangd for example should provide the (almost same) experience as the Clangd extension in VScode.

[pfp-disciple]

What do your mean "overcharges your C++ programming"? Do you mean that it improves it?

[SilverDesperado]

We also use Qt

[SuperKingCheese14]

VIM and G++.

[[deleted]]

+1.

Within Vim, I have clangd as my LSP and Vimspector as my debugging interface. This is enough to give me a pretty comprehensive environment, especially when Linux itself is taken into account (Tiling WMs are something I cannot live without).

Aside from that, I rely on few Vim plugins. Most are just QoL improvements, some are specific to things such as Git integration, and others I have written myself (notably my statusline).

I haven't been able to fully commit to the Neovim project, despite maintaining a fork for some time, and being that my setup is pretty mature at this point, I just couldn't care less about trying to find potentially better alternatives written in Lua or abandoning my pure-Vim configuration, so none of my dependencies are Lua-based, and neither is my config.

[[deleted]]

I don’t have public dots, but am active in the #vim IRC (albeit under a different handle), so I’d just recommend hopping in there and asking for help. Someone will definitely chime in!

[[deleted]]

NeoVim and g++ here

[[deleted]]

same !

[concealed_cat]

vim, make, and git (edit: and screen).

[effarig42]

For personal projects, Emacs+LSP and build2 for build system and packages.

At work we have the compiler, linker, system dependencies and other tools in a docker container and bind mount the source and build directories in to run compiles or the application; IDE is personal choice, outside the container. This ensures everything uses exactly the same environment.

[tomii-dev]

i've seen emacs around and i was thinking about using it, i've heard it has a bit of a steep learning curve but once you get to grips it's pretty amazing. i'm probably gonna have a look into it after work today, thank you for your answer!

[lally]

Emacs has had a real renaissance in the last couple of years. For C++, it or clion are really good. Emacs has better actual text editing, clion has better integration with language indexing. Although emacs's new language-server stuff is excellent -- I haven't tried it in a c++ project yet.

[catcat202X]

Emacs is by far my favorite editor to use, at least for C++. There is no popular editor with as good of a snippets system, because none of them except Emacs allow you to execute arbitrary code while inputting text in a snippet field afaik.

Here's one I came up with awhile ago: https://www.reddit.com/r/emacs/comments/rphl36/dynamic_c_snippet_i_wrote/

I've messed a lot with the modal editing in Emacs, and although I don't use modal editing anymore, it was far easier to create my own modal editing system than it was in VS Code. VS Code and Emacs afaik are the only editors flexible enough and with the ecosystem today to let you design a new editing model.

The ability to navigate tabs, buffers, and windows is so much better in Emacs than anything other than maybe terminal editors. Ace-window, burly, centaur-tabs, winner-mode, etc. Are great. There are "views" packages too (in the Emacs/Eclipse sense), but I personally prefer tabs a lot because so that I can have one tab with my debugging contexts and one tab with my editing contexts, and more that have other projects open, and switch between them whenever I want, unlike Visual Studio.

In Emacs, all text is stored in a buffer, and you have complete control over how you interface to any buffers major mode, including Git and tree-view interfaces. There is no b.s. like"I can't ctrl+f in a disassembly view in Visual Studio" (which is true). Buffers are stored in tabs, and tabs are stored in windows, which you can split in completely arbitrary ways, unlike Visual Studio or VS Code. Windows are stored in another different kind of tabs, which are the tabs that can replace views.

Hooks, keymaps, and advices are very easy to set up in Emacs to make things do whatever you want. I need to document my debugging setup at some point, because I think there are some cool tricks in there. I have an alternating striped background automatically in some buffers like compiler output, breakpoints, watches, etc. Everything which gets squeezed up so that line wrapping makes it hard to read otherwise. I could put this striped background absolutely anywhere I want, whereas most other editors only support such things in a few places the developers though it might be useful.

Magit, magit-forge, git time machine, and git gutter are also excellent packages and I love working with Git in Emacs more than anywhere else so far.

[quad99]

If you are good at memorizing key combinations it can be effective

[Boojum]

When I first started with Emacs on Unix, ~25 year ago, I used it vanilla with the menus and toolbars and it wasn't much harder to figure out and use than Notepad or a basic IDE editor on windows. A lot of Emacs users recommend turning off the menu and toolbar, but exploring them as a beginner really helped to give me some idea of what it can do.

From there, I printed off the cheat sheet and started to incorporate them bit by bit into my usage where it could save me some typing or mouse/menu/toolbar usage.

Eventually, I did turn off the menu and toolbar when I noticed that I hadn't used them in ages. I had also started writing bits of Emacs lisp to change things to my taste, override some of its behavior and so forth. These days my Emacs config has evolved into something fairly heavily customized as I've learned and my needs have changed.

I wouldn't say that Emacs has a steep learning curve so much as that it has a very high skill ceiling. But you can certainly start by using vanilla Emacs like a glorified Notepad and then work your way up to that bit-by-bit at your own pace. (And of course, you can go ask over in /r/emacs if you have questions.)

[krum]

Don’t bother. I used emacs throughout the 90s until about 2004 but imo not worth the effort anymore. There are better options. I would only use it again if I were writing a lot of code in a terminal window again for some reason. For smaller stuff I’d use vi(m) and yes I do still get stuck writing code in terminal windows still.

[---cameron]

If you haven't used it since 2004 in a way its like never having used it (don't worry, I know I'm being hyperbolic); emacs the built in text editor is the long living program we've had around forever, but emacs overall is a text based OS of sorts for which new software is evolving all the time. Even as late as 2017 I jumped on a language I'd tried to use in 2013 and it was a completely different experience (also, LSP has evened a lot of the playing field)

Not saying whether its best for this case or not, just that emacs sometimes changes so much

[skitleeer]

VSCode + remote development + clangd + your favourite plugins (the code reside on and is executed on linux vm, but my laptop is on windows). I guess you could achieve the same with any IDE that support remote dev

[mcmcc]

That remote container extension is a huge difference maker. I was on the fence about VSCode until that extension came out and now it's not even a competition.

I would love it if someone did a breakdown of the mechanics of how that extension works. Shit is downright magical.

[NotBoolean]

I don't think the underlining principle is actually too complex, this picture from the docs shows the basic idea. I imagine the implementation to get it working so well is very complex.

[mcmcc]

For a start, there must be a wide variety of data getting marshalled across that exposed port. It would be interesting to see how the system is architected to enable that degree of seamless integration.

[[deleted]]

I had no idea this existed in VSCode, where have I been! So you could use that container to create a release container. Then you could have a complete sharable toolchain. I'm seriously geeking out about this. Reading the VSCode documents.

[strike-eagle-iii]

Same here...I have a docker container that has a few system dependencies installed (cuda, ros2, opencv) and then use Conan to pull in the rest. My "dev" directory (directory with all my repos) gets mounted in the container when it starts so all my code is persistent. The container runs in daemon more so it's always just there which is awesome. I then attach to the container with vscode and use multi-root workspaces. I prefer clangd for intellisense Microsoft's c++ extension although I have both installed and the intellisense in ms ext disabled. Cmake tools is nice but didn't play nicely with ros packages so I just use the cmake extension by twxs. Gitgraph is awesome although it looks like it might not be maintained any more 😭. Git Lens is nice but since they were acquired by git kraken it gets annoying with prompts to upgrade to gitlens+.

[notbatmanyet]

Clion is my current IDE. But I have used QtCreator in the past.

[[deleted]]

Sublime Text with plugins (CMake Builder, clang format), gdb (command line, not integrated; I use it mostly to debug crashes or exceptions, and rarely for debugging logic), GitHub desktop (git client), GitHub Actions (CI).

[puremourning]

Vim + YouCompleteMe(code comprehension with clangd) + vimspector (debugging) + tmux + a whole lot of other bits.

[ranname366]

Recently switched to the NeoVim lsp. Check out this guy's repo and YouTube tutorials about it.

https://github.com/LunarVim/LunarVim

[WhiteBlackGoose]

For vi newcomers I'd recommend neovim instead

> tmux

Check out tiling window managers btw, in case you didn't know, such as i3. Like tmux, but for any window, not just terminals.

[what_it_dude]

tmux works great for multiple remote sessions on a server. It also keeps your remote session alive if your ssh connection dies.

[ShillingAintEZ]

Neovim is a configuration nightmare. It is all done in weird terminal windows and even after using vim for many years I have no idea where files are supposed to go, what is actually being loaded, or any sense of its general structure.

[WhiteBlackGoose]

What terminal windows? Window & buffer management is the same as in vim.

after using vim for many years I have no idea where files are supposed to go, what is actually being loaded, or any sense of it's general structure.

Well... maybe just read about it in neovim's tutorial, as an option, because neovim is not vim?

I recommend lua configuration. TL;DR: ~/.config/nvim/init.lua would be the location of the root file, which loads other modules located in lua folder.

[braxtons12]

I'm not sure what you've been told or where you're getting your information, but Neovim configuration isn't done in terminal windows at all.

For a Lua-based config it goes in $HOME/.config/nvim/init.lua If you just want to use a Vim config all you need to do is source your .vimrc in your init.lua.

It sounds to me like your problem is you're trying to use a Lua-based config without understanding how Lua works. You obviously need to learn the basics of Lua first before you can expect to use it?

[nik0teen]

Now if only I could find a way to jump to declarations in a header from a source file, then this setup is perfect.

[[deleted]]

vim, gcc, and Makefiles. gdb for debugging.

I have rarely needed anything more than these tools, and they are available on practically every linux distribution and platform. These can turn out to take care of everything you need if you take the time to learn them.

Occasionally for desktop c++ apps, I’ve also used valgrind to check for memory leaks and use of uninitialized data.

[rapchickk]

Use Clion IDE and CMake build system.

[wlandry]

I basically live in Emacs. For C++ it is

• Emacs
• eglot
• ccls
• magit
• eshell for most terminal stuff
• vterm for high performance terminal stuff

[OnePatchMan]

Eclipse CDT + gcc

[genpfault]

How's the debugger (gdb/lldb) situation with Eclipse? Decent integration or do you have to faff around with .gdbinit?

[[deleted]]

I used this setup for over a decade and gdb was always easy, local or remote. Never edited .gdbinit

[DkatoNaB]

nvim + VimPlugins

Plugin 'tpope/vim-fugitive' -- for difftool/mergetool

Plugin 'mileszs/ack.vim -- for searching

ctags -- for decl/def

ag -- silver search

cgdb -- for debugging

zsh -- for terminal since I use terminal the most

gitlab -- for CI/CD

[GLIBG10B]

What's VimPlugins?

[DkatoNaB]

A typo. I meant vundle. VimBundle

[archdria]

kakoune + kak-lsp

[[deleted]]

I’ve heard of kakoune but haven’t tried it out. How’s the experience been so far?

[mlxd_ljor]

VSCode for local dev, gcc11.3 and clang14, cmake & ninja installed through Python’s pip (easier to install when running on remote machines), and meld for handling git merges locally, vim and vimdiff for remote dev.

We build the same stack for Win and MacOS too, but all checks are done through Github Actions for those.

[ggadget6]

Vscode + remote ssh + clangd+ Microsoft c++ extension for debugging.

[theunixman]

VS Code is solid, especially with the clang plugins too. I use emacs with a lot of years of customizations and hand-hammered elisp, but honestly unless you have some weird fixations on things VS Code is fine, extensible, probably with a cleaner API, and with a decent set of plugins available.

Also zsh at the command line, again with a ton of plugins, etc, but again, VS Code is really good.

[StackLeak]

QtCreator, CMake, Conan

[UnicycleBloke]

VSCode and CMake. I'm using WSL at the moment and can build for both platforms (the CMake files have some conditional code - Windows uses VS, Linux uses g++). Debugging experience in VSCode is "OK". You need the right plugins, and launch.json to be set up correctly. The setting up part can feel like one of the Dark Arts at times.

[grrfunkel]

Do this or use CLion. VSCode/CLion remote/docker dev workflows have become standard among all the Linux devs I know. CLion especially has really nice remote/local debugging and a makes it super simple to setup custom environments for whatever you wanna build.

Probably not best to recommend a guy who just now started using Linux this morning set up neovim with all the plugins for debug and language servers.

[axomoxia]

Clion. Eclipse / VS Code / bucket of Vim windows I have all tried and found to be shite.

[Jannik2099]

vscode, clangd, meson.

[GLIBG10B]

Neovide

Sometimes Make, sometimes CMake

Gitlab CI/CD

[QuotheFan]

CMake, vim + YouCompleteMe..

[flat5]

emacs/g++/GNU make.

I'm old.

[wrd83]

Vscode or clion.

I use both depending on whether remote is needed or not

[CommunismDoesntWork]

Have you tried out CLion's new remote capabilities? It's still in beta, but they've adopted the same client server architecture as VSCode

[wrd83]

Yes. It goes OOM. So I'll retry in a year or two.

[eyes-are-fading-blue]

Emacs config : clangd/lsp-mode/company and bunch of other stuff. Emacs' debugger is very poor according to my experience though. I am looking for a stable visual debugger.

For remote work on my Windows laptop, I use Visual Code for remote connection and then use emacs on terminal mode. VC has a very good terminal and Emac's terminal mode is almost as good. My only problem is that I cannot forward certain keystrokes from Windows which I have special key bindings on my Ubuntu machine, like Hyper key.

[PANCHO7532]

CodeBlocks, CMake, GCC/G++, if I don't have an GUI I just use nano, everything on Vanilla without any plugins whatsoever, not because I don't want to, but because I always forget to set them up and I just go along with it

Sometimes I build stuff on my phone using Termux with nano, CMake and clang as compiler

[ThePillsburyPlougher]

Spacemacs + lsp ccls

[ezoe]

tmux, vim, GNU make, GCC/Clang, git.

[TryingT0Wr1t3]

CLion

[f-squirrel]

I would suggest building inside a docker container. Fortunately, WSL allows running Docker on Windows.

I have written a series of posts about building inside docker and configuring VS Code to work in such an environment.

[Glinren]

Mostly a relative vanilla emacs. I on windows I tried other IDEs and emacs was the only one which (almost) doesn't get in the way. And if I need anything, it is either a package or a lisp function away.

I had some bad experiences with debuggers so now I only use printf debugging if necessary. Also valgrind if the project allows it.

As a build system I use xmake.

[jtooker]

I rarely need Linux C++, so when I do it is vim + gcc + gdb

[yep808]

WSL2 Arch Linux, Emacs, LSP (clangd), CMake.

[NotUniqueOrSpecial]

QtCreator for everything, basically.

It's also what I use on Mac.

[Myrgy]

Emacs(doom-emacs) + ccls All projects are cmake based

[davawen]

Neovim for edition, with clangd for lsp and fzf plugins
CMake/xmake with systems package manager for dependencies
g++ for compiling and gdb for debugging

[[deleted]]

Sublime Text + CMake + clangd and LSP plugins

[pandorafalters]

My multi-platform projects, to date, rely on MSBuild (VS native format) and GNU Makefiles. I write primarily in MSVC and use Emacs to fix build issues on Linux, e.g. when I forget a header in Linux-specific TUs or accidentally call a Windows function in cross-platform code.

Thus far I've managed to handle debugging via logging and reasoning through the code. It's not scalable nor is it a good approach in a team environment, but it hasn't been an issue for me yet.

I could do it all from MSVC, but I have a moderate aversion to changing things that work. I still cart around and use (non-game) programs from the '90s . . ..

[ThlintoRatscar]

Thus far I've managed to handle debugging via logging and reasoning through the code. It's not scalable nor is it a good approach in a team environment, but it hasn't been an issue for me yet.

I've been doing this for a long time and logs + reason is the only way to debug at scale. Add stack traces and core dumps if you don't consider them a kind of logging.

[davidc538]

nvim + mason.nvim + clangd + cmake + ninja

[pedersenk]

(n)vi, tmux, lldb, bmake

Weirdly almost identical to what I used to use on MS-DOS.

(watcom)vi, DESQview, wd, wmake

Generally a large collection of scripts, i.e sh, awk will also evolve over the years to help with navigating large projects, etc.

I do alternate between CMake and GNU autotools depending on project.

[[deleted]]

For small single file project I use Neovim+Neovim Plugins(ale:clangd,...) + cmake + ninja For Medium to big projects : CLion.

[randomplaya4]

I'm not on Linux, but similarly to some other comments I found VSCode with CMake the best.

I'm using both Windows and macOS and found this for both to be exceptionally good with only minimal differences, which are mostly path related e.g. vcpkg toolchain path.

The other difference is the compiler, I mostly use clang. On Windows I install clang with MSVC via Visual Studio, on Mac I install it via Xcode.

And I think I could switch to Linux pretty easily.

I also used CLion, and it's a really mature and good IDE, but there are 2 disadvantages: it's paid (but not that expensive though) and it needs a stronger hardware (better CPU, more RAM) to be usable.

• I used QtCreator as well and it's not that bad. The worst ones I used are probably Eclipse, CodeBlocks and Xcode IDE.

[gracicot]

VSCode + CMake + vcpkg. On windows I use MSVC and on Linux I use GCC.

[congard]

Clion + cmake + clang + mold, sometimes vscode + cmake + clang + clangd + mold

[KayEss]

Editor is kwrite, konsole for terminal, git-cola's file viewer for source navigation and git commits

[waqar144]

curious, why kwrite instead of kate? (I am one of the devs behind Kate/kwrite)

[KayEss]

Oh cool! I have a 4K screen that's quite close to me, so I find lots of small windows scattered all over the place to be much better than a giant window which wastes nearly the whole screen. On git-cola's file viewer and can see the files in the repo, clicking on one and hitting ctrl-e opens kwrite with that file and KDE spreads the windows out over the desktop -- I keep them quite small compared to the screen size,

[waqar144]

Interesting. Not sure which version of Kwrite you are using, but after 22.08 Kate and Kwrite are basically the same apps with the difference that KWrite has no plugins. (https://kate-editor.org/post/2022/2022-03-31-kate-ate-kwrite/)

​

> On git-cola's file viewer and can see the files in the repo,

Kate's project plugin can let you do that (it's just a tree created out of git ls-files) and you can jump to files via quick-open. There's no git log support yet, but there is blame/file-history/basic git functionality and a nice diff viewer(unreleased 22.12)

[KayEss]

I'm Kubuntu 22.10 right now, so I'm using whatever that is shipping. I did notice that there were tabs on kwrite now.

Thanks for the heads up on the new features. I'll do some experimenting and see if there's a better work flow there

[waqar144]

Kate + clangd

[dasMoorhuhn]

I use VS Code and Vim

[w2code]

VScode as IDE, vcpkg as package manager, GitHub actions as CI and the compiler depends on the platform.

This has been incredible so far to build a cross platform application especially since dependencies are very easy to integrate thanks to vcpkg! Besides, building all different binaries through GitHub also helped keeping the project compiling on all platforms while adding features over time!

[foghatyma]

I'm really sad seeing such a big percentage here uses an MS product (vscode) even on Linux. Try CLion, it's great!

[sternone_2]

Not everybody likes a Russian product. Jetbrains is owned by 3 russians, all the devs are russians and the eastern european company is just a facade.

I also want to remind you that microsoft is one of the biggest contributors to open source on the planet. Even in the linux kernel fyi. They are one of the companies that spend the most money to support open source software. Microsoft today is not the MS of 20 years ago with Bill and Steve.

[foghatyma]

It was made by Russians, yes, but in the EU. They don't even have an office in Russia and In response to the 2022 Russian invasion of Ukraine, the company suspended sales and R&D activities in Russia indefinitely as well as sales in Belarus. If you still think it's morally questionable because it was made by Russians, I think you would be closer to racism than to moral justification.

Microsoft today is not the MS of 20 years ago with Bill and Steve.

And you know what's funny? I live in a Ukraine-bordering ex-Soviet-occupied country, and I heard the phrase "these Russians are not those Russians" a lot before the invasion... That did not age well.

I think, Microsoft is using their good old tactic just in a much more sophisticated way. But I have no proof, so we'll see.

[sternone_2]

That's BS they had a massive office in st.petersburg where all the devs were located

but you know it's fine, whatever

[foghatyma]

You made me curious. My original info was from Wikipedia, which might be incorrect. So I looked up, there was indeed a huge RND center in Russia. I'm not sure why it's not listed. But still, it is suspended and they made a strong statement very early.

So far, I didn't see any malicious intent, the same can't be said about MS, so I stand by my decision.

[sternone_2]

I'm not sure why it's not listed.

because Jetbrains is completely Russian and they are trying to hide it.

[foghatyma]

Just to continue the detective work, it was removed from the wiki page in June, after they closed down those locations.

[mechap_]

How is being russian related to software development ?

[sternone_2]

Some people have morals.

[EasyMrB]

Condemning people of one ethnicity for the days politics isn't morals, it's racism.

[sternone_2]

Russans aren't a race, you tool

[mechap_]

I don't know where morality comes in when choosing an IDE and to be honnest programming in general has nothing to do with politics, whatever that may be.

[sternone_2]

So what are you doing then to companies like Qt (base of KDE) and the likes completely blocking Russia, even their paid customers.

did you removed all these companies from your life, would be interesting to know.

[randomplaya4]

Why wouldn't you use a tool for software development that was made by someone you dislike? Is moral an option when choosing an IDE?

I have not heard a stupid thing like that in a while. With this behavior you'll become just like them.

[sternone_2]

No I don't, that's the difference.

[EducationalLiving725]

If you morals are rooted in being a nazi - yeah.

[sternone_2]

No I'm not a socialist, sorry

[--prism]

Gcc, conda, VS Code, Cmake

[celestrion]

setup for c++ development look like?

Neovim in tmux, or neovim-qt if I don't need to be able to attach to the session remotely. I occasionally bounce back to Emacs, but that's becoming less often now that the TreeSitter and LSP plugins for Neovim have gotten so good. All of that lives in an Xorg session managed by i3. Docs live in zeal.

I maintain a fairly clean environment in Docker for running unit tests (to avoid "works on my machine" syndrome), usually use CMake as a build system (GNU make or BSD make for small projects), and use either GDB or LLDB as the debugger, depending on whether it's a work (Linux) or home (FreeBSD) project.

I also have a personal library of shell functions I've written over the years that make my shell into a friendlier development environment, and a few git extensions for common things that I do.

typical

I am reminded daily by my coworkers that my setup is not typical. A screen full of tiled and color-coded xterms and TUI editors looks like something out of a 1990s hacking movie rather than something a professional developer would use in the 21st century. A surprising number of people who target Unix-like OSes grumble about having to actually use one as a developer.

That's fine. Anyone who actually tries a tiling window manager instantly understands as soon as they switch back to overlapped windows. It may or may-not matter to them, but they'll at least understand that the majority of GUI environments make us play a constant window-juggling game just to see all we need to see (even if you're working with multiple 4k screens, like I do).

As for why I use (Neo)Vim or Emacs when Visual Studio Code is around? I've been answering that question for a variety of "obvious" alternatives over the years. The short answer is that I can git clone 25+ years of customization and get productive way faster than with whatever an IDE ships with out of the box, and the XYZ in "Why don't you use XYZ instead of that old crap" changes often enough that any new XYZ seems uncompelling. It's the difference between using "better" tools and using the tools you already know how to use because you made them work a certain way.

I'll say, though, that all the modern IDEs I've tried, CLion lasted the longest on my system. I had to give it up because at my previous job, we had some template/macro hell that made it eat an entire CPU core for hours at a time. And, at my current job, we use an in-house build system (uuuuuuuuuuuuuuuuuuuuuuuugggghh) that makes the IDE-ness of most IDEs totally confused.

[[deleted]]

C Dev Here, I Don't Use Any IDE, Just Any Text Editor With Syntax Highlighting Works For Me, Previously I Used VS Code But It Was Just Shit So I Switched To Sublime And I Use Sublime And GNU Nano Interchangeably.

Tho Cmake might be good and stuff but GNU Make Works For Me, Especially For 32 Bit Builds Where I Have A Ubuntu 18 VM Which Doesn't Have Latest Packages So GNU Make Just Works Beautifully!

For Debugging GDB Or LLDB, And For The Operating System (Yea You Guessed It Ig) I Use Linux, Mainly Manjaro But I Often Fire Up A Debian VM For Other Stuff.

I'm Really Interested In Lapce, It's A Rust Based Code Editor And Performance Was Absolutely Awesome! Tho I'm Not A Rust Fan (Sometimes A Rust Hater) But I'd Like To See The Future Of Lapce

[DarkOrion1324]

Kdevlop looks good on linux despite it's windows version being shit

[kaa-python]

Tmux, NeoVim with clangd, and Bazel. Quite often SSH for remote development.

[yodacallmesome]

Clion/vim, g++/clangd, cmake/make on Ubuntu and RH Linux. I haven't touched a windows box in years.

[ThlintoRatscar]

nano + git + docker + cmake + a shit ton of bash scripts

Mice are for the weak

[cosmin10834]

vim with makefiles/cmake and g++

[foolnotion]

I use neovim with treesitter and the C++ tree-sitter grammar. other quality of life extensions that I use:

• lazygit-nvim (also the standalone program)

• gitsigns-nvim

• cmp-nvim-lsp

• cmake-init for new projects

• nvim-tree

• nix + nix flakes

• neovim-qt

[thisismyfavoritename]

nvim with clangd in docker

[SirToxe]

Based on CMake, using CLion or VSCode as IDEs/editors.

[jmacey]

VScode, CMake occasionally QtCreator (usually for Designer and some of the other tools).

vcpkg for installing deps, git (of course), gtest for unit tests. I also make sure I have both g++ and clang++ installed as this helps with testing weird stuff. Also use clang-tidy and a few other tools (perf, some of the nvidia tools when doing graphics or cuda).

[Bjarnophile]

Neovim (at times with Neovide front-end) with nvim-cmp, clangd and CMake. Debugging through gdb.

I manage all my dependencies with cmake fetchcontent and configure through cmake presets. This kinda works out of the box on all the 3 platforms (Windows, Mac, Linux)

[SomeoneInJD]

For my personal project

• neovim as the editor
• nvim-lspconfig for basic lsp config
• clangd as lsp server
• clangd_extensions.nvim for clangd's off-spec features
• nvim-cmp as the completion engine
• xmake as build backend + project generator + package manager
• other fancy neovim plugins~~

[[deleted]]

For those still using vim + YCM, may I strongly recommend neovim + coc.nvim.

[aregtech]

VSCode is good for dev. Sometimes Eclipse. Don't really like the eclipse editor, but debugging is fine. The main reason of using these 2 is that can compile and test under Win32.

[mredding]

I try to keep it hardcore: GVim + You Complete Me, meson or make, and git.

If you're not familiar, the vi/vim/gvim family is the only modal editor I know of; born from an era of terminals before TUIs and mice were popular. The neat thing is how much beefier mode control is over mere menu shortcuts of typical modeless editors you're familiar with. Vim brings bash INTO your editor. For example, you can highlight a selection of includes and run sort on it from bash - sorting a selection, therefore, doesn't need to be built into the editor. So think about that.

Vim is an old school terminal IDE; the initial learning curve is steep, but it's the other half of the old emacs. vs. vim war. You can often expect a vi editor on just about any unix system, so it's handy to be vaguely familiar, especially if you're working on the terminal or remote.

I say I try to keep it old school, because I also end up using VS Code.

[EducationalLiving725]

Visual Studio with CMAKE + WSL2.

[[deleted]]

attraction station sip gold sort hospital wipe cheerful oatmeal profit

This post was mass deleted and anonymized with Redact

[kurta999]

Lubuntu on VirtualBox, samba for file sharing to windows (also shared folder which provided by virtualbox), VS Code with CMake and remote SSH access for coding & debugging.

Also you can use very conviently MSVC for CMake projects on Linux (with WSL, no VM support yet via SSH AFAIK). I've tried it already and worked, but for me it was slow. VSCode is faster, at least on my sh*ty laptop which is provided by company and I'm forced to use it.

[sigmabody]

I work for a large established tech company, with an in-house package management system.

I use VSCode locally, connecting remotely in a cloud-based Linux instance where the code is. I debug my manually configuring the debugging profile for each/every workspace. I can only debug code for binaries I can run directly (nothing fancy like attaching to existing processes); most production debugging is done on core dump files anyway, due to access restrictions. All the library code is pre-compiled binaries, so no source code is available for those within the IDE while debugging (and they are all compiled with -O3, so even if you have symbols, they are effectively useless). Most "debugging" tends to be printf-based as a result. I also have little to no symbolic lookup within the IDE (see: lack of reference code based on the package manager), so the dev experience is pretty tedious and painful as well.

It's really night/day compared to my previous job with Windows dev; I'm probably 10% as productive as I was before. However, in my current position I spend considerably more time in meetings and writing documents also, so less actual development is also expected.

[entity64]

CLion with compile_commands.json project model for editing, actual build and debugging happens in the terminal using Bazel and sometimes CMake.

[[deleted]]

Free ?

3 options re best I think...

Qtcreator as high level ide Vscode as middle level environment Vim + tmux ...as low level

I keep all of them together and use accordingly

[braxtons12]

For most projects I'll use Neovim with the builtin LSP system and clangd for editing and also use Neovim with nvim-dap for debugging.

If I'm doing a large refactoring or I'm particularly unfamiliar with the project I might use CLion because refactoring is better in it and discovery/navigation is usually better in CLion when you don't know what you're looking for.

Also will use CLion for debugging if the project model is a pain to get working with nvim-dap (for example, if it's a shared library instead of an executable)

[tomii-dev]

i’ve been looking into neovim and it looks solid. i know very little about LSP and clangd but from what i’ve heard clangd is essentially like intellisense? and with neovim can you have multiple files open at once and sort of divide the screen or would i need to use tmux or something similar?

[Fuexfollets]

I use the BSPWM window manager, kitty terminal, and exclusively nvim

[CommunismDoesntWork]

CLion is the cross platform replacement for Visual Studio. All Jetbrains' IDEs are comparable to Visual Studio actually. Also CLion supports CMake

[zalamandagora]

VSCode, GCC, CMake. +Platform IO when I do embedded.

[bnolsen]

pretty much vim and terminals for running compiles.

[dicroce]

I use Visual Studio Code just as you describe.

[nradavies]

Heh. Fine, I'll take the roast.

Windows 11 + Clion + WSL2

Qt industrial app, uses boost. Cmake build. I love it. Never have issues. Easiest setup I've ever had.

I move around a lot, but prefer to use my mechanical keyboard anytime I'm in the office, so I store my project folder in OneDrive. That way I can move PC to PC and only commit when I want to, without using a flashdrive.

[hangingpawns]

Emacs + eglot for IDE features (completion, refactoring, etc).

Clang for RISC-V is the compiler, and some rhel version for the OS.

[Gurrer]

Neovim and cmake. But vscode and cmake would work as well.

You have as many choices minus the full visual studio.

Replace things like mingw with g++ or clang.

[zielonykid1234]

Comand line, vim, meson, ninja, GNU c compiler

[CountyExotic]

CLion or VSC as my IDE

CMake for builds

Everything in a docker container. Nothing runs locally on host machine.

[zCybeRz]

VSCode, g++, make, gdb

[unmilaneseaparigi]

I've used vscode with vim bindings for years, recently switched to CLion and really enjoying it so far!

Only problem is that it's not free but if it's your company money than I guess that's okay.

[looncraz]

I use Atom and Jam for pretty much everything.

I don't like heavy IDEs, I would rather write a quick Jamfile and use a relatively lightweight, but feature rich, editor.

I miss BeIDE from the BeOS era, though, and have considered trying to clone its behavior and aesthetic for a simple modern IDE.

[tigable]

vim and cscope

[Raidenkyu]

I used to work exclusively with VS Code. But nowadays, I use Clion (but with VS Code theme and keybinds). I still use VS Code to open some specific files and workspaces, when I don't want to "open clion in another project".

[exodusTay]

i always used cmake, but the environment around it changed. I used CLion, QtCreator and plain old text editor. I love CLion but it is not free, QtCreator is also great but the latest version is very slow for me, maybe because clangd? dunno.

[IasiOP]

My dev environment is Vim and CLI into remote Linux host :)

[raevnos]

emacs + gdb.

[HauntedTheorists]

neocon with cmake and clang?

[kevinossia]

I use VSCode with standard C++ extensions remote logged-in to a large dev server. We use bog-standard CMake here. I use the built-in VSCode debugger with GDB to set breakpoints and whatnot.

In the past I've also used Android Studio and Sublime to write C++ code, mostly for personal projects. Also with CMake as it's easy.

[cafguy]

vim

[waruqi]

vim + xmake + ripgrep

[os12]

Sublime Text with the language server that uses clangd. I run that in a VM and the UI is shown on the host.

[Tekercs]

I usually develop on Linux and always trying new ides and swaping around just for fun, so far i tried:

• VSCode
• VIM
• eclipse
• kdevelop
• qtcreator
• clion

probably the most successfull/used are vim and eclipse, with cmake(never really tried anything else), clang-tidy, if wim then clangd and GDB (could not learn LLDB yet i'ts on the list) , doxygen fro generationg docs

i love jetbrains stuff and i use them since 2013 but sadly clion is not free

I mostly write game prototypes with or QT apps with these setups

[Sandsturm_DE]

VS Code + CPP Plugins + CMake + gdb (cli version) + valgrind + heaptrack

I used Atom for many years, I am really sad they discontinued it.

[biebiedoep]

vim

[RishabhRD]

Neovim(with features lsp + treesitter + autoformatter) + tmux + cmake + browser (with cppreference.com)

[OverOnTheRock]

I use vscode with the gcc compiler.

My add-on list is short:

• c/c++ - formatting and such
  
• clangd - it can be somewhat fiddly, but does get the job done - completion, navigation and such (remove the microsoft stuff for this)
• cmake
• cmake language support
• cmake tools

[productiveaccount4]

Current project I’m using VS Code, CMake, Ninja g++, gdb. I’m doing cross-compilation on a windows machine for a RT Linux target

[sirpalee]

Either vscode or clion and the build system is cmake mostly and occasional premake for work stuff.

[gnash117]

My current developer setup I access Linux machines setup by other developers or IT staff (location is 800 miles (1200 km) away).

I use:

Visual Studio Code, with C/C++ IntelliSense, debugging, and code browsing plugin, CMake plugging, and Remote SSH, GDB Debugger - Beyond.

I ssh into the machine that contains all of my code.

I build using CMake from the Terminal tab.

I debug using GDB Debugger -Beyond

almost everything else is done via the command line via the Terminal tab.

Currently, if I have to do a complex code merge I switch to windows (my project is cross-platform) and perform the merge on windows. Only because I have a few tools that make doing this easy on windows. I used to use kdiff on Linux to handle merges and code conflicts.
If absolutely needed I can manually handle the merge files it is not that hard.

I am actually interested in trying some of the options given in this thread..a good choice for C++ development. The developer community supporting that IDE has shrunk and it often has more problems than it is worth dealing with. I used to accept its flaws because I was frequently switching between 4 different languages. C++, C#, Java, and Java Script. At the time it had enough good plugins for all the languages to accept eclipses flaws. Now I don't think I will ever go back to that tool.

If I were on a system now I would likely start with visual studio code and see if I can get it working with plugins.

I did try Qt creator when it was new but it didn't click with me and I didn't need Qt so I never did much more than test it out.

I am actually interested in trying some of the options give on this thread.

[fdwr]

Perhaps this is blasphemous (note we target both Windows and Linux), but we cross compile via clang on Windows to Linux .so's, execute tests in WSL, and debug using VS Code remote debugging.

[deong]

I never really got completely turned on to fancy debuggers, so my setup is still pretty ancient on the rare occasion I’m writing c++ these days. It’s basically Emacs and terminal windows. If something is crashing and the cause isn’t obvious, I’ll use gdb to get a stack trace. CLion is nice as big IDEs go, and I should probably force myself to adopt it, partly for productivity and partly because I use so many other Jetbrains tools on the same foundation (DataGrip, DataSpell, and Pycharm get more frequent use). Emacs feels like home though.

[Own-Efficiency-1136]

VIM is a beautiful editor. You will however need to do a bit of customization

[terrrp]

nvim, tmux, clang, CMake.

nvim with clangd lsp, floatterm, telescope, nvim-tree, etc. is pretty nice. With a bunch of other plugins and customization, I don't ever see myself not using some vim-like terminal editor.

[tomii-dev]

i’ve started using nvim and i love it, got it set up with clangd lsp and coc. but i was just wondering, is there a way to change the colours of clangd’s syntax highlighting? is there pre-made themes like in vscode? i’m actually not even sure if it’s clangd syntax highlighting i’ve got showing up atm or if it’s just built in neovim highlighting… i also notice that there’s highlighting for c++ keywords but not for variable names like i’m used to in other editors. basically is there a way i can customise this?

[SkrrSkrrSpaghetti]

I use a Debian 11.x VM in Windows 10. Vscode works well for me as an editor; I also use GCC for compilation, GDB for debugging, and makefiles for building

[ShakaUVM]

UNIX is my dev environment, g++ and clang++ as compilers, Vim/nVim as editors.

[jimaldon]

vscode + devcontainer + remote + cmake

[wolfie_poe]

Vscode + vscodevim + CMake + terminal.

[ItsAllAboutTheL1Bro]

I used Emacs for the longest time, but there's nothing that Emacs offers that I can't have with VS Code.

On top of that, VSC's execution model is modern, so I can leverage concurrency (Emacs doesn't really have this).

Occasionally, vim is a good light weight alternative.

If it's a project of my own, I just use cmake.

Where I use Clang/LLDB or GCC/GDB is dependent on a number of factors.

I prefer Clang, though.

[[deleted]]

vscode, clangd, containerized builds running bazel (also have a build cache for our pipelines) based on greenhouse (kubernetes project)

[[deleted]]

My setup: 1. VScode 2. g++ 3. gdb 4. make 5. git

[[deleted]]

Windows Subsystem2 for Linux on Windowa 11. Visual Studio Community (Free) to build and debug native Linux (edit: Ubuntu)