|
|
Log in / Subscribe / Register

Development statistics for the 7.1 kernel

By Jonathan Corbet
June 15, 2026
Linus Torvalds released the 7.1 kernel as expected on June 14. This development cycle brought in a lot of new features — and a lot of new developers as well. The time has come for our traditional look at where the changes in 7.1 came from, with a digression into how our community may be changing in general.

This release saw the merging of 15,849 non-merge changesets from 2,479 developers. That makes 7.1 one of the busiest development cycles in the kernel's history; only four other releases brought in more commits. The 6.7 release remains the busiest ever, with 17,284 commits; the size of that release was driven by the ill-fated addition of the bcachefs filesystem and all of its development history. The 5.8, 5.10, and 5.13 also brought in more commits than 7.1, though by much smaller margins.

The number of developers working on 7.1 does set a new record, beating the short-lived record of 2,362 set by 7.0. The trend here merits some attention, but we'll start with the usual numbers. The most prolific developers working on 7.1 were:

Most active 7.1 developers
By changesets
Johan Hovold 1811.1%
Thomas Weißschuh 1751.1%
Eric Biggers 1681.1%
Stefan Metzmacher 1551.0%
Krzysztof Kozlowski 1480.9%
Rafael J. Wysocki 1470.9%
Russell King 1300.8%
Tejun Heo 1250.8%
Christoph Hellwig 1220.8%
Eric Dumazet 1200.8%
Jakub Kicinski 1190.8%
Sean Christopherson 1130.7%
Thorsten Blum 1010.6%
Thomas Zimmermann 860.5%
Dmitry Torokhov 850.5%
Andy Shevchenko 840.5%
Mauro Carvalho Chehab 840.5%
Chuck Lever 790.5%
Bartosz Golaszewski 770.5%
Lorenzo Stoakes 770.5%
By changed lines
Jakub Kicinski 12636712.7%
Roman Li 10577710.7%
Namjae Jeon 544455.5%
Andrew Lunn 161801.6%
Eric Biggers 144711.5%
Stefan Metzmacher 144031.5%
Taniya Das 119561.2%
Alexei Starovoitov 114101.2%
Andy Shevchenko 76730.8%
Mauro Carvalho Chehab 76370.8%
Christian Brauner 74830.8%
Pankaj Patil 71810.7%
Christoph Hellwig 63680.6%
Krzysztof Kozlowski 59930.6%
Besar Wicaksono 58730.6%
Dmitry Baryshkov 57870.6%
Tejun Heo 56980.6%
Derek J. Clark 52880.5%
Vincent Donnefort 50330.5%
Ratheesh Kannoth 49920.5%

About the [KSDB] links

As an experiment, in this article, links marked [KSDB] point into the subscriber-only LWN Kernel Source Database, where more information can be found.

Johan Hovold [KSDB] was the biggest contributor of changesets in this development cycle, with a lot of cleanup work in the SPI subsystem and beyond. Thomas Weißschuh's [KSDB] work covered many parts of the kernel, including the build system, nolibc, SPARC architecture code, and more. Eric Biggers [KSDB] has been busily refactoring the kernel's cryptographic code. Stefan Metzmacher [KSDB] contributed improvements to the SMB filesystem implementation, and Krzysztof Kozlowski [KSDB] continues to work throughout the system-on-chip and devicetree subsystems.

In the lines-changed column, Jakub Kicinski [KSDB] removed a large chunk of old and unmaintained networking code, including the ISDN, Bluetooth CMTP, and ATM subsystems. Roman Li [KSDB] added yet another big set of amdgpu header files. Namjae Jeon [KSDB] has brought back the older NTFS filesystem implementation and added a lot of new features to it. Andrew Lunn [KSDB] removed a set of unmaintained networking drivers.

Nearly 8% of the commits in 7.1 carried Tested-by tags, while almost 51% had Reviewed-by tags. Both of those numbers are relatively low compared to recent releases. The top testers and reviewers this time were:

Test and review credits in 7.1
Tested-by
Daniel Wheeler 895.8%
Fuad Tabba 613.9%
Gavin Shan 402.6%
Shaopeng Tan 402.6%
Mohd Ayaan Anwar 402.6%
Jesse Chick 402.6%
Mostafa Saleh 362.3%
Punit Agrawal 342.2%
Jon Hunter 332.1%
Zeng Heng 312.0%
Lad Prabhakar 291.9%
Peter Newman 281.8%
Eric Biggers 271.7%
Venkat Rao Bagalkote 221.4%
Randy Dunlap 211.4%
Reviewed-by
Konrad Dybcio 3343.1%
Dmitry Baryshkov 3002.8%
Andy Shevchenko 1971.9%
Krzysztof Kozlowski 1811.7%
Christian König 1701.6%
Ilpo Järvinen 1611.5%
Simon Horman 1401.3%
Frank Li 1341.3%
Geert Uytterhoeven 1221.1%
Christoph Hellwig 1191.1%
Jonathan Cameron 1181.1%
Gary Guo 1141.1%
Andrea Righi 1031.0%
Rob Herring 1000.9%
Lorenzo Stoakes 940.9%

Daniel Wheeler [KSDB] maintains his perpetual position as the kernel's top credited tester. On the review side, Konrad Dybcio [KSDB] added his tag to 334 changes while Dmitry Baryshkov [KSDB] tagged 300; both performed reviews almost exclusively for Qualcomm drivers and devicetree files, mostly written by their Qualcomm colleagues.

Development for the 7.1 release was supported by 230 employers that we were able to identify; the most active of those were:

Most active 7.1 employers
By changesets
(Unknown)216013.6%
Intel14359.1%
Google12277.7%
AMD8285.2%
Qualcomm7875.0%
Red Hat7454.7%
(None)6944.4%
NVIDIA5953.8%
Meta5353.4%
(Consultant)5003.2%
SUSE4592.9%
Oracle3902.5%
Arm3342.1%
Renesas Electronics2891.8%
NXP Semiconductors2541.6%
IBM2151.4%
Huawei Technologies2101.3%
Kylin1811.1%
Linutronix1711.1%
SerNet1551.0%
By lines changed
Meta15658315.8%
AMD13673613.8%
(Unknown)767387.7%
Qualcomm758477.6%
Samsung553915.6%
Google545375.5%
Intel489174.9%
NVIDIA373743.8%
Red Hat357063.6%
(None)351783.5%
Oracle158371.6%
SerNet144031.5%
Arm130301.3%
SUSE122081.2%
NXP Semiconductors117771.2%
Huawei Technologies115801.2%
Realtek103141.0%
(Consultant)99841.0%
Marvell82820.8%
Amutable74830.8%

As usual, there is little change here from previous development cycles.

The developers keep coming

There is one thing that is clearly changing, though. The 7.0 development-statistics article noted that the number of first-time kernel contributors has been growing. The 7.1 cycle continued that trend with 530 new contributors [KSDB], far more than the previous record of 489 set by 7.0. The numbers now look like this:

[First-time contributors bar
chart]

This trend, which shows no signs of stopping, is almost certainly driven by the increasing availability of LLM-based development tools; it has made itself felt in a number of ways. There are 299 commits in 7.1 that include an Assisted-by tag indicating the use of such a tool. The number of actual commits created with LLM involvement must be significantly higher, though; a number of developers are clearly not complying with the kernel's rules for disclosing that use.

These new developers are showing up in surprising places. The serial-line IP (SLIP) protocol implementation, for example, has seen almost no attention outside of maintenance changes for years, but it is now seeing fixes like this one from Weiming Shi [KSDB], a developer who first showed up in 6.19. The long-unloved floppy driver received this fix (since reverted) from 6.17 first-timer Guangshuo Li [KSDB]. The OMFS filesystem received its first non-mechanical change in many years from first-timer HyungJung Joo [KSDB].

The most prolific 7.1 first-timer, Michael Bommarito [KSDB] with 60 commits, contributed fixes to the SMB filesystem, the SCTP network protocol, the Bluetooth subsystem, io_uring, the SCSI subsystem, the amdgpu driver, the RDMA RoCEv2 implementation, and beyond. Almost all of those patches carried Assisted-by tags. There are few kernel developers who could make substantial changes across that much of the kernel; the ability of a previously unseen developer to do that is something new. Whether any developer, new or old, can fully understand substantive patches to that range of kernel subsystems is a different question.

Then, there is the seemingly infinite stream of typo fixes that has turned into an outright flood in recent times. As the documentation maintainer, I welcome these changes as a way for a new developer to become familiar with the development process, but I also try to encourage developers to move on to more substantial changes — advice that is taken less often than I would like.

Of course, access to an LLM is not the only reason a developer might enter our community. A minimum of 132 of the first-time developers seen in this development cycle can already be associated with an employer. Qualcomm leads the pack with 15 first-time developers; AMD employed 14, and Google 12. In total, 51 companies employed first-time 7.1 developers.

One of the many motivations behind bringing Rust into the kernel was the hope of attracting younger developers into the community. A total of five of the new developers (just under 1%) touched Rust files (those whose names end in ".rs"). Three of those developers contributed single, small patches, one added a number of tracepoints to the binder driver, and one (Eliot Courtney [KSDB]) contributed 23 commits, 19 of which were to the in-progress "nova" driver for NVIDIA GPUs. So Rust may be bringing in developers, but not yet in huge numbers yet.

Overall, the areas most frequently touched by new developers were:

Subsystem# developers
Documentation78
net66
other drivers52
drivers/net49
drivers/staging47
sound46
include36
drivers/gpu/drm35
other fs33
tools32
arch/arm6426
kernel25
fs/smb19
drivers/usb17
drivers/iio15
drivers/hwmon13
drivers/bluetooth10
MAINTAINERS10
drivers/platform10
drivers/i2c9
mm8

There are some interesting patterns here. The crowd of new developers working on the documentation is nice on its face .... but see "typo fixes", above. The number of first-timers changing the MAINTAINERS file could be of concern; there has been an episode or two recently where an unknown developer tried to claim maintainership of a subsystem, a prospect that is worrisome for obvious reasons. In this case, roughly half of the MAINTAINERS changes accompanied new drivers submitted by the new developer in question. There are a couple of previously unseen developers who showed up and claimed the maintainership of an existing subsystem, but they used email addresses from the company involved and, at a first glance, look legitimate. Meanwhile, the staging tree was meant to be a way for new developers to enter the community; it appears to still be serving that purpose.

One number that stands out is the number of new developers contributing to the SMB filesystem. These developers are not fixing typos; instead, they are addressing what appear to be serious, perhaps security-relevant bugs. Whether these developers are running their own tools to find bugs, or whether instead there is some sort of organized effort to direct new developers at those bugs is unclear. What does seem clear is that anybody who is using SMB in a setting where security matters may want to apply extra diligence to following kernel updates for a while.

As the numbers in the first part of this article show, the kernel's development process appears to be rolling along at its usual fast pace — or even a bit faster. But things are changing. New development tools have facilitated the entry of a large crowd of new developers into the community. If enough of them stay around, it should not take long to change the makeup of the kernel community — and how that community works — substantially. We live in interesting times.

Index entries for this article
KernelReleases/7.1


to post comments

Rust and "new devs"

Posted Jun 15, 2026 18:21 UTC (Mon) by jpeisach (subscriber, #181966) [Link] (7 responses)

> One of the many motivations behind bringing Rust into the kernel was the hope of attracting younger developers into the community. A total of five of the new developers (just under 1%) touched Rust files (those whose names end in ".rs").

I'm still learning Rust (thanks for reminding me to do my Rustlings) - and I know Greg KH said something about Rust being great for new devs, but as it stands:
- some pieces of code dont have rust bindings/abstractions
- the kernel can be a bit of a complex codebase to learn, and learning it in *another* language where most of the code is C, makes it less useful

Rust and "new devs"

Posted Jun 15, 2026 19:53 UTC (Mon) by jmalcolm (subscriber, #8876) [Link] (6 responses)

This may be a good use case for AI. Have it explain the parts of the code that you do not understand. It does not have to write anything for you.

Cognitive impact

Posted Jun 15, 2026 19:55 UTC (Mon) by jpeisach (subscriber, #181966) [Link] (5 responses)

> Have it explain the parts of the code that you do not understand.

I'm personally hesitant against doing that, might as well do the experience to fully grasp it - after all I have the time to look at it.

Cognitive impact

Posted Jun 15, 2026 20:32 UTC (Mon) by khim (subscriber, #9252) [Link] (4 responses)

You can simply go and verify what LLM would tell you. Keep in mind that it's right about 90-95% of time and don't be afraid to poke holes in LLMs explanations — and it will work fine.

Looking on the random code and pulling good information from it is very good use of LLMs, just keep in mind that they are not always right and final responsibility to look on what LLM finds out is yours. But even if it only find the right places to look in 90% of time it's still a big help.

Cognitive impact

Posted Jun 16, 2026 7:09 UTC (Tue) by epa (subscriber, #39769) [Link] (3 responses)

Perhaps we need an “LLM’s commentary on Linux” where one of the frontier labs runs their best model over the whole kernel source, getting it to explain line by line, and puts the result as a cross-referenced website. The hard part would be dialling down the usual LLM verbosity.

Cognitive impact

Posted Jun 16, 2026 15:18 UTC (Tue) by iabervon (subscriber, #722) [Link] (2 responses)

I've been thinking that a good way to figure out what documentation to write, to avoid rattling on forever about things that really are obvious and never getting to the things other people need to know (or writing so much uninteresting text that readers don't find the important information in it) would be to have an LLM try (not especially well) to explain the code and then for the human expert to document those things that the LLM got wrong. I've been finding that my reaction to inaccuracies in LLM output about my system has been largely that there's no way a human would know the right answer there, either, but new human developers are much less willing to express what they guess about the system. I think half of the benefit of being interviewed by a good tech writer is that they're willing to say the wrong things that people would think if you didn't improve your documentation.

Cognitive impact

Posted Jun 16, 2026 16:02 UTC (Tue) by kleptog (subscriber, #1183) [Link]

> I've been finding that my reaction to inaccuracies in LLM output about my system has been largely that there's no way a human would know the right answer there, either

I've had some success with pointing an LLM at a piece of code and asking it to identify the parts that are not obvious, and for those parts to describe what it thinks it does and to suggest a comment. It does a pretty good job of identifying unusual stuff and the explanations are ok, but just as often they're bugs. As a bonus, once you fix the comments it suggested, then it's more readable for humans and LLMs alike.

It also works to ask it to review your README.md for suggestions for improvements. It's also done wonders for my error path handling, since it auto-suggests useful error messages including all the relevant details. Good error messages are important but sometimes they're a distraction while you're coding.

Coding LLMs have seen every common programming pattern under the sun, so if it's not recognising it it definitely needs a comment.

Cognitive impact

Posted Jun 19, 2026 20:14 UTC (Fri) by mathstuf (subscriber, #69389) [Link]

My idea has been to trawl historical code reviews and to extract out details that are commented on, but not written down anywhere. Then take those details and integrate them into the developer and/or user documentation as needed.

More of my patches merged

Posted Jun 15, 2026 20:55 UTC (Mon) by rosalie (subscriber, #164575) [Link]

This is the second kernel version with more of my kernel patches merged, it feels like an achievement in my open-source journey to be able to get my code changes into such a widely used project, though my changes are nothing major, mainly the drivers/hid/hid-sony.c changes to add support for Rock Band game controllers, it still feels like an achievement!

The kernel code isn't that difficult to read, which I was surprised by, but there's next to no documentation on how to use certain functions so I mainly looked at how other HID drivers do things and tried to mimick that, which I'm sure is intentional.

<soapbox>

Posted Jun 15, 2026 21:57 UTC (Mon) by mjbommar (subscriber, #184543) [Link] (1 responses)

That "Assisted-by" guy here :)

For the record, I submitted a patch on 2.6.19 back in December 2006 when the 802.11 softmac stack was young and still broken on my laptop. I think that means I'm technically not a first timer, if anyone is really counting.

That said, your broader point remains. I think we all appreciate the difference between "understanding" something and the ability to recite the call graph with your eyes closed after three beers.

The gap between those two things is real and I don't think most people - myself especially in this context - should pretend to understand the code they submit in the latter sense. That's reserved for the select few whose shoulders we stand on.

But I doubt I'm ruffling too many feathers when I suggest that writing software of any complexity without formal verification (which is often impossible), especially in languages like C, especially when a code base spans many years and many authors and many styles, is practically guaranteed to induce human failure modes.

So I think the real question we ought to be asking, heavily motivated by the impact of LLM's on both the productivity function and the changing nature of offensive security, is how we can help more people like me safely contribute.

Safely can mean a lot of things. Yes, there's the Rust conversation re: memory management. But more broadly, I think it's documentation, testing, processes, and - probably most controversially - a little more convergence of standards, styles, and even, *gasp*, code.

All of these things are tools that transcend the individual maintainer. And in my opinion, much like the smartest, fastest, strongest hominids lost out to the ones who built the best tools and shared that knowledge, we are at a point where competitive dynamics will do the same to us.

P.S.: since I know some of you have asked or wondered about the why, I'll say that rolling up your sleeves and grabbing a shovel feels much better than sitting anxiously and worrying about what happens when frontier models fall into the wrong hands. I still remember when security was about Theo and Linus's latest argument; let's just say, we're not in Kansas anymore.

<soapbox>

Posted Jun 16, 2026 1:41 UTC (Tue) by marcH (subscriber, #57642) [Link]

> That said, your broader point remains. I think we all appreciate the difference between "understanding" something and the ability to recite the call graph with your eyes closed after three beers.
> ...
> So I think the real question we ought to be asking, heavily motivated by the impact of LLM's on both the productivity function and the changing nature of offensive security, is how we can help more people like me safely contribute.
> Safely can mean a lot of things. Yes, there's the Rust conversation re: memory management. But more broadly, I think it's documentation, testing, processes, and - probably most controversially - a little more convergence of standards, styles, and even, *gasp*, code.

I always found debuggers to be fantastic code "explorers", including with the kernel. Nothing better to observe some call stacks "live" in their almost natural habitat. Unfortunately, debugging the kernel seems to almost always require some dark magic - whether it's some secret QEMU spell or something else, rarely practiced and even more rarely documented. Sad.

Linaro fired devs?

Posted Jun 16, 2026 5:25 UTC (Tue) by hrw (subscriber, #44826) [Link] (3 responses)

I have a feeling that this is the first Linux kernel release without Linaro presence in companies list.

Linaro fired devs?

Posted Jun 16, 2026 14:34 UTC (Tue) by Wol (subscriber, #4433) [Link] (2 responses)

>I have a feeling that this is the first Linux kernel release without Linaro presence in companies list.

-Pedant mode on- I think you mean "first Linux kernel release in recent times". A quick Google tells me that Linux is roughly twice as old as Linaro :-)

Cheers,
Wol

Linaro fired devs?

Posted Jun 16, 2026 14:58 UTC (Tue) by hrw (subscriber, #44826) [Link] (1 responses)

Yes, yes.

Linaro was founded in 2010. I was one of first hired to work there. Before it got a name.

I assume that kernel developers moved to some member companies (like Qualcomm). But I do not plan to do research what happened.

Linaro fired devs?

Posted Jun 17, 2026 5:56 UTC (Wed) by jirisl2 (guest, #184573) [Link]

Layoffs might have been involved yes.

My new developer experience with LLM

Posted Jun 16, 2026 9:35 UTC (Tue) by mvollrath (subscriber, #183387) [Link] (1 responses)

My first patch was to stable leading up to 7.0.

I have an old PC that I still use for everything, and with RAM prices being what they were (and still are), felt like I should put some effort into maintaining that old hardware. I started with the ethernet driver, since it seemed like it should be pretty straightforward, and I'm generally interested in telemetry.

I started by pointing Claude at the main source file and asking it to find bugs. It found maybe 6 hits, and one of them turned out to be a very real bug. I spent a few days reading code and documentation to convince myself that it was indeed a very real bug.

With that new understanding of the patterns, next I wanted to be sure I could hack it without the LLM. I did code review on the same driver looking for any resources allocated in the driver probe which could be leaked on probe failure, and found one.

The next step was automating away that tedious code review, so I learned enough about coccinelle to scan all of the PCI ethernet drivers for the same probe leak, and it found another in a different driver.

I feel like the assistance with that first step was the real value of the LLM. It's kind of like having an expert to ask questions about any part of the kernel anytime you want, with the usual caveats of interacting with LLM for any purpose.

I do use the Assisted-by tag when the LLM was involved in finding the bug/change, iterating on the implementation, or reviewing the work. I can understand why a lot of people don't. There's no context about what parts of the work were done by the LLM, unless you add some noise to the commit description. If I'm feeling proud of myself for finding a bug or a big optimization myself, adding that label to the commit kind of steals the thunder. That's one reason I set out to make a few commits without any LLM assistance. Now I'm over it, and I'm just gonna do what works and follow the guidelines.

Maybe the guidelines can evolve to work around the psychology. For example, if it were acceptable to credit the LLM with different tags, that might help. On some commits I would credit it with Suggested-by, on others Reviewed-by, for implementation Co-authored-by, or Assisted-by as a shorthand for any or all of these. The normalization of anthropomorphism is a little creepy, but there's a reason we don't just use Assisted-by when a real person helps with a commit. The reduction cuts both ways.

My new developer experience with LLM

Posted Jun 16, 2026 12:59 UTC (Tue) by csamuel (✭ supporter ✭, #2624) [Link]

Thanks so much for that description of your progression & work, that's great! It really does show how these tools can assist in understanding and learning when used in a considered and thoughtful way.

I think more precision in describing the involvement of LLMs in the development of a patch is a good suggestion, it would (I think) give both better transparency and insight into changing strengths and weaknesses as the tooling (and the community) evolves.

No tests?

Posted Jun 16, 2026 19:05 UTC (Tue) by NAR (subscriber, #1313) [Link] (2 responses)

Out of curiosity I looked at one of the patches and the code makes sense - what strikes me though is the lack of tests. I might be spoiled by $WORK where test coverage is measured and enforced, but I still find is strange that a bugfix goes into the kernel without some kind of test triggering the fixed fault and showing that the fix is indeed a fix (and hopefully ensuring that the bug doesn't come back).

No tests?

Posted Jun 18, 2026 13:15 UTC (Thu) by mjbommar (subscriber, #184543) [Link]

My experience working across such a broad swath of the kernel is that attitudes vary from pro-test, like KUnit required or out-of-tree suite pass required, to practically anti-test folks who will reject unit tests or even descriptions of testing in commit messages.

No tests?

Posted Jun 27, 2026 11:12 UTC (Sat) by andy_shev (subscriber, #75870) [Link]

FWIW, for the lib/ we now *require* any new feature to be accompanied with a test case.


Copyright © 2026, Eklektix, Inc.
This article may be redistributed under the terms of the Creative Commons CC BY-SA 4.0 license
Comments and public postings are copyrighted by their creators.
Linux is a registered trademark of Linus Torvalds