The GNU Compiler Collection 11 (GCC 11) will be ending stage one development in mid-November to get the release process underway.

Within hours of Linus Torvalds releasing the Linux 5.9 kernel, the GNU folks maintaining the GNU Linux-libre downstream released their version of the kernel that prevents the loading of binary-only modules as well as the loading of binary-only firmware/microcode blobs.

Oak Ridge National Laboratory's Leadership Computing Facility (OLCF) announced on Thursday that they are funding improvements to the GNU Compiler Collection (GCC) around GPU compute offloading.

One of the most interesting projects out of Google Summer of Code 2020 has been the ongoing work for allowing individual code files to be compiled in parallel, building off work last year in addressing GCC parallelization bottlenecks. The final report for GSoC 2020 on this work has been issued.

While LLVM's Clang C/C++ compiler was traditionally known for its faster build speeds than GCC, in recent releases of GCC the build speeds have improved and in some areas LLVM/Clang has slowed down with further optimization passes and other work added to its growing code-base. As it stands right now, GCC is faster than Clang at compiling the Linux kernel.

At the GNU Tools Track during this week's Linux Plumbers Conference was an interesting talk by Red Hat's Ben Woodard. He shares his perspective on how the GNU dynamic linker (ld.so) could be ripe for an overhaul in the 2020's.

For a number of years the GNU Compiler Collection has shipped experimental support for the DWARF 5 debugging data format while finally for next year's GCC 11 release it might be deemed stable and used by default.

For the past two summers student developer Giuliano Belinassi has been working under Google Summer of Code in working to address GCC parallelization bottlenecks and ultimately a goal of allowing single source files to be split up for compilation in parallel by GCC. In particular, being able to split the compilation of large source files across multiple CPU cores. The latest patches on this "-fparallel-jobs=" was sent out today as we approach the end of GSoC 2020.

If looking for a text editor that offers more features than the recent release of Nano 5.0, GNU Emacs 27.1 is out.

The Fujitsu A64FX ARM processor that has 48 cores per node and 32GB of HBM2 memory that currently powers the fastest supercomputer is beginning to see GCC compiler support.

GNU C Library 2.32 (glibc 2.32) is now available as this important library for Linux and other Unix-like operating systems.

The GNU Debugger (GDB) has merged initial support for debugging of eBPF code that is traditionally consumed by the Linux kernel as part of this in-kernel special purpose virtual machine.

While GCC with GNU Make and other build systems can scale nicely in compiling many files concurrently, there has been an ongoing GCC effort to be able to parallelize more of the GNU Compiler Collection work when compiling large source files.

The popular GNU Nano terminal text editor has reached version 5.0.

Making waves just over a year ago in the GNU Compiler Collection community was the "Ranger" project for on-demand range generator that's been worked on for several years at Red Hat. While their goals for GCC 10 didn't pan out, it's looking like in the next few months more of the Ranger infrastructure will land and thus putting it in the window for GCC 11.

Version 10.2 of the GNU Compiler Collection (GCC) is now available.

Well this is a huge Friday morning bummer: the GNU C Library (glibc) is dropping support for the very interesting Restartable Sequences (RSEQ) as some design changes need to be made, thus restarting work on restartable sequences.

The GCC crew is preparing to issue their first stable point release to the GCC 10 series next week.

The toolchain support for the Synopsys DesignWare ARC HS processors is now ironed out with the GNU C Library (glibc) finally mainlining the ARC port.

Earlier this year was news of GNU Guix wanting to replace their Linux kernel usage with the Hurd microkernel. For those interested, the project recently began producing system images with indeed Hurd wired up for this software distribution.

Experimental patches under discussion for the GNU C Library (glibc) would make it easier to dynamically load optimized libraries (shared objects) on systems depending upon the CPU in use and its hardware capabilities. This glibc-hwcaps work stems from the desired work on being able to better leverage Linux performance optimizations on AMD Zen-based systems but the hardware capabilities patches themselves can help any CPU microarchitecture family in more easily shipping optimized support.

Binutils 2.35 was branched this weekend as this important component to the open-source Linux ecosystem.

Following the proposal at the end of last year over GCC 11 aiming to default to C++17 for its C++ front-end, that change is now in place for GNU Compiler Collection 11.

The Free Software Foundation (FSF) has renewed their attacks against the US Patent and Trademark Office (USPTO) and software patents in general, this time in relation to the COVID-19 / coronavirus crisis.

For those making use of GNU's "adns" asynchronous DNS client library, important security updates are out today.

For several years now GCC has offered a embeddable JIT compiler that for GPL applications can serve as a bytecode interpreter, an experimental Python compiler, and other possible use-cases with this libgccjit library. There now are patches pending for bringing libgccjit to Windows.

With the recently minted GCC 10 compiler there was a request to see some fresh benchmarks at different compiler optimization levels and flags like LTO.

When seeing GCC 11 in its early development state pick up a new -flarge-source-files option I was curious what that was all about....

Since last year's GCC 9 release the C++17 support has been considered stable and with the changeover to it as the default C++ dialect having not happened for the recent GCC 10 release, developers are now looking at increasing the default C++ version to 17 for next year's GCC 11 release.

The recently released GCC 10 compiler landed initial coroutines support for this major C++20 feature but wasn't enabled unless explicitly enabling that option.