#linux kernel documentation

[muffinlance]

Woo got Linux working! On a related note I have gotten over any fear of breaking things through the command line and also can now roll back to an earlier system backup. Yes those are related. In my defense, breaking things in interesting ways is a great way to figure out what's actually going wrong.

[andmaybegayer]

Man I forgot how good this video is, it's just this guy doing a hell of a deep dive on everything he knows about the absolute minimum requirements of a working self-hosting Linux.

It's great because he'll be like okay. In order to explain why we're building this file I need to explain RAM filesystems. Have you heard of RAM filesystems? No well okay look here's how you find documentation for the kernel, here's the difference between block devices, RAM devices, pipe-backed devices and pseudofilesystems, here's some fun facts about SAMBA, FUSE and ProcFS. RAMdisk is actually a block device in case you didn't realize. Anyway so here's how you build this, and the distinction here is important because we pass it to a kernel flag. Oh yeah kernel flags. Kernel flags are defined in this file here...

He just keeps drilling down on a lot of very niche knowledge that, if you're going to be dealing with this stuff, you'll have to learn eventually, but all packed in to one neat one and a half hour talk, and done almost entirely as a live demo running on his laptop complete with building the demo system and booting it in qemu.

[layover-linux-official]

Write One to Throw Away?

If you're in the software industry for long enough, you'll hear this advice eventually. There's an infamous Catch-22 to writing code:

You don't deeply understand the problem (or its solution space) until you've written a solution.

The first solution you write will have none of that hindsight to help you.

So it naturally shakes out that you have to write it at least one time before you can write it well, unless you're stricken with exceptional luck. And the minimum number of attempts you will need is two: one to throw away, and a second attempt to keep.

It's just math. It's just logic. Write one to throw away. It's got the world's easiest proof. You'd have to be some kind of idiot to argue with it!

Okay, hear me out...

As you work on bigger and older projects, you will continuously be confronted with a real-world reality: that requirements are an input that never stops changing. You can make the right tool for the job today, but the job will change tomorrow. Is your pride and joy still the right tool?

If you're like most developers, your first stage of grief will be denial. Surely, if we just anticipate all the futures that could possibly happen, we can write code that's ready to be extended in any possible direction later! We're basically wizards, after all - this feels like it should work.

So you try it. You briefly feel safe in the corrosive sandstorm of time. Your code feels future proof, right up until the future arrives with a demand you didn't anticipate, which is actually so much harder to write thanks to your premature abstractions. Welcome to the anger stage. The YAGNI acronym (you ain't gonna need it) finally registers in your brain for what it is - a bitter pill, hard-won but true.

But we're wizards! We bargain with our interpreters and parsers and borrow checkers. Surely we can make our software immortal with the right burnt offerings. We can use TDD! Oops, now our tests are their own giant maintenance burden locking us into inflexible implementation decisions. Static analysis and refactoring tooling! Huh, well that made life support easier, but couldn't fix fundamental problems of approach, architecture and design (many of which only came into existence when the requirements changed).

As the sun rises and sets on entire ISAs, the cold gloom eventually sets in. There is no such thing as immortal software. Even the software that appears immortal is usually a vortex of continuous human labor and editing. The Linux kernel is constantly dying by pieces and being reborn in equal or greater measure - it feels great to get a patch merged, but your name might not be in the git blame at all in 2 years time.

I want to talk about what happens when your head suddenly jumps up in astonished clarity and you finally accept and embrace that fact: holy shit, there is no immortal software!

Silicon is sand

... and we're in the mandala business, baby.

I advocate that you write every copy to be thrown away. Every single one. I'm not kidding.

Maybe it'll be good enough (read adequacy, not perfection) that you never end up needing to replace your code in practice. Maybe you'll replace it every couple years as your traffic scales. But the only sure thing in life is that your code will have an expiration date, and every choice you make in acknowledgement of that mortality will make your life better.

People are often hesitant to throw out working code because it represents years of accumulated knowledge in real-world use. You'd have to be a fool to waste that knowledge, right? Okay. Do your comments actually instruct the reader about these lessons? Does secondary documentation explain why decisions were made, not just what those decisions were? Are you linking to an issue tracker (that's still accessible to your team)? If you're not answering yes to these type of questions, you have no knowledge in your code. It is a black hole that consumed and irreparably transformed knowledge for ten years. It is one of the worst liabilities you could possibly have. Don't be proud of that ship! You'll have nowhere to go when it sinks, and you'll go down with it.

When you write code with the future rewriter - not merely maintainer - in mind, you'll find it doesn't need to be replaced as often. That sounds ironic, and it is, but it's also true. Your code will be educational enough for onboarding new people (who would rewrite what they don't understand anyways). It will document its own assumptions (so you can tell when you need a full rewrite, or just something partial that feels more like a modification). It will provide a more useful guiding light for component size than any "do one thing well" handwave. And when the day finally comes, when a rewrite is truly necessary, you'll have all the knowledge you need to do it. In the meantime, you've given yourself permission to shit out something sloppy that might never need replacing, but will teach you a lot about the problem domain.

This is independent of things like test suite methodology, but it does provide a useful seive for thinking about which tests you do and don't want. The right tests will improve your mobility! The wrong tests will set your feet in cement. "Does this make a rewrite easier?" is a very good, very concrete heuristic for telling the two apart.

Sorry for long-posting, btw. I used this space to work through some hazy ideas and sharpen them for myself, particularly because I'm looking at getting into language design and implementation in the near future. Maybe at some future date, I'll rewrite it shorter and clearer.

TL,DR:

Every LOC you write will probably eventually be disposed or replaced. Optimize for that, and achieve Zen.

[adafruit]

The SC16IS74x is an I2C to UART converter

If you know us, you know we luuuuuv I2C as a near-universal interface for sensors, GPIO expanders, OLEDs, and other various devices under our Stemma QT family: https://www.adafruit.com/search?q=stemma+qt 🌱. But we still bump into some UART devices: https://www.adafruit.com/search?q=uart here and there—GNSS/GPS units, MP3 playback chips, fingerprint sensors, LIDARs, and more.

These can be annoying if you only have one UART port-or none at all! So we put together this SC16IS74x breakout. It can use either the SC16IS740: https://www.digikey.com/en/products/detail/nxp-usa-inc/SC16IS740IPW-128/1301043 or SC16IS741: https://www.digikey.com/en/products/detail/nxp-usa-inc/SC16IS741AIPWJ/4486521 chips-both essentially the same for our purpose: providing a bidirectional UART with flow control. Address jumpers on the back allow you to select up to four devices on one I2C bus—and there's even native Linux kernel drivers: https://www.kernel.org/doc/Documentation/devicetree/bindings/serial/nxp%2Csc16is7xx.txt 🧠.

[winterinhimring]

Where do I learn how to code and use linux? I want to try it but I don't know anything about coding.

I will do my best to help! The answer to that question is very long if I write it all out here, but a lot of it has been answered by other people, so I'll give you an overview and link you to some resources along the way.

The good thing is that you don't need any programming knowledge to use Linux. If you just want to try out the Linux operating system and see what it's like, I would start by downloading a program like Oracle's VirtualBox: https://www.virtualbox.org/

This will allow you to basically run a second, simulated, computer on your actual computer. From there, you can download a Linux image and install it, run it inside VirtualBox, and get familiar with the operating system. This has the additional benefit that if you do something wonky to your Linux virtual machine (VM for short) by mistake, you can just delete it and recreate it and no harm will be done to your actual computer. For a step-by-step explanation, see: https://ubuntu.com/tutorials/how-to-run-ubuntu-desktop-on-a-virtual-machine-using-virtualbox#1-overview

Short aside: Linux is not a monolithic operating system like Windows or MacOS. Linux, written by a man named Linus Torvalds, is a "kernel" made up of certain very basic computer functions, and the rest of the operating system, things like the graphical user interface (GUI, to nerds like me) doesn't come with it. To be usable by normal people, Linux has to have that functionality filled in by other programmers, which creates something called a distribution, or distro for short. Ubuntu, Debian, RedHat, Linux Mint, and OpenSUSE are all Linux distros. Different distros are designed for different purposes. Ubuntu and Mint are both pretty friendly to normal folks who want to write documents, check their email, etc. RedHat is for large companies. There's a distro called Kali that's for cybersecurity and penetration testing. Etc. etc. etc. There are tons of distros. If you don't know which one to pick, I recommend Ubuntu or Mint, as I have experience with both, and they're fairly easy to use.

From this point out, a search engine will be your best friend. There are lots of helpful tutorials online, and also answers to almost any question you can imagine. If you're unsure where to start, documentation from the website of an official Linux distribution, like Ubuntu, is usually reliable, though it can be kind of opaque if you're not used to reading tech-ese. The tutorials on Ubuntu's site, however, seem to be structured with beginners in mind, and I would run through this one to start with: https://ubuntu.com/tutorials/command-line-for-beginners#1-overview

Once you get to the point of having specific questions about how a command works or how to make the operating system do something, I would take a good look at any answers from StackOverflow, which is basically a website for computer people of all skill levels to ask each other questions ranging from the basic to the ridiculously obscure. If you're wondering it, chances are good someone on StackOverflow has asked it.

Other than that, click around your new VM, create files, find programs, etc. If you really get stuck, I'll try and help, but keep in mind I may very well be searching StackOverflow myself. XD

The other cool thing about VMs is that you can try multiple operating systems, i.e. Linux Mint (https://linuxmint-installation-guide.readthedocs.io/en/latest/) which is pretty user-friendly, as I recall.

Once you get to the point where you actually want to install Linux, you'll want to back up your computer to an external hard drive so you can restore from the backup if something goes wrong, and then follow the instructions for your chosen Linux distro. LibreOffice runs on Linux and can open most Microsoft file types, so you shouldn't need to move your files to a different type, you'll just need to copy them somewhere (like another external hard drive or a thumb drive) and then copy them back when you're done with the installation. Obligatory word of warning: installing Linux on your actual machine, as opposed to a VM, WILL OVERWRITE YOUR ENTIRE HARD DRIVE. Do this with caution. Restoring from a backup is possible, so as long as you backed everything up you will not lose any data, but it can be a pain in the neck and if you're not particularly tech-savvy, you may have to go to a computer repair store to get them to do it.

Now, as to your question about learning to code: this requires no VM and no new installation; you can start doing that today. There are almost infinite tutorials online about how to start coding. CodeCademy.com is a pretty decent one, as I recall, though it's been a long time since I used it. There's also a channel on YouTube called BroCode that puts up free 'how to get started in this programming language' tutorials, which are pretty beginner-friendly. I would recommend that you start with either Python or Java (NOT JavaScript; it's not the same thing as Java, and it's a really annoying programming language, so don't do that to yourself). Python has syntax that is more similar to English than most programming languages and it is pretty powerful, but it may confuse you when you start moving to other programming languages. Java is less immediately comprehensible but probably more representative of programming languages as a whole.

Hope this helps! Feel free to send me follow-up questions or ask for clarification if I lapsed into tech-speak and this doesn't make sense.

[iphonehistory]

Apple Unveils Mac OS X

Next Generation OS Features New “Aqua” User Interface

MACWORLD EXPO, SAN FRANCISCO

January 5, 2000

Reasserting its leadership in personal computer operating systems, Apple® today unveiled Mac® OS X, the next generation Macintosh® operating system. Steve Jobs demonstrated Mac OS X to an audience of over 4,000 people during his Macworld Expo keynote today, and over 100 developers have pledged their support for the new operating system, including Adobe and Microsoft. Pre-release versions of Mac OS X will be delivered to Macintosh software developers by the end of this month, and will be commercially released this summer.

“Mac OS X will delight consumers with its simplicity and amaze professionals with its power,” said Steve Jobs, Apple’s iCEO. “Apple’s innovation is leading the way in personal computer operating systems once again.”

The new technology Aqua, created by Apple, is a major advancement in personal computer user interfaces. Aqua features the “Dock” — a revolutionary new way to organize everything from applications and documents to web sites and streaming video. Aqua also features a completely new Finder which dramatically simplifies the storing, organizing and retrieving of files—and unifies these functions on the host computer and across local area networks and the Internet. Aqua offers a stunning new visual appearance, with luminous and semi-transparent elements such as buttons, scroll bars and windows, and features fluid animation to enhance the user’s experience. Aqua is a major advancement in personal computer user interfaces, from the same company that started it all in 1984 with the original Macintosh.

Aqua is made possible by Mac OS X’s new graphics system, which features all-new 2D, 3D and multimedia graphics. 2D graphics are performed by Apple’s new “Quartz” graphics system which is based on the PDF Internet standard and features on-the-fly PDF rendering, anti-aliasing and compositing—a first for any operating system. 3D graphics are based on OpenGL, the industry’s most-widely supported 3D graphics technology, and multimedia is based on the QuickTime™ industry standard for digital multimedia.

At the core of Mac OS X is Darwin, Apple’s advanced operating system kernel. Darwin is Linux-like, featuring the same Free BSD Unix support and open-source model. Darwin brings an entirely new foundation to the Mac OS, offering Mac users true memory protection for higher reliability, preemptive multitasking for smoother operation among multiple applications and fully Internet-standard TCP/IP networking. As a result, Mac OS X is the most reliable and robust Apple operating system ever.

Gentle Migration

Apple has designed Mac OS X to enable a gentle migration for its customers and developers from their current installed base of Macintosh operating systems. Mac OS X can run most of the over 13,000 existing Macintosh applications without modification. However, to take full advantage of Mac OS X’s new features, developers must “tune-up” their applications to use “Carbon”, the updated version of APIs (Application Program Interfaces) used to program Macintosh computers. Apple expects most of the popular Macintosh applications to be available in “Carbonized” versions this summer.

Developer Support

Apple today also announced that more than 100 leading developers have pledged their support for the new operating system, including Adobe, Agfa, Connectix, id, Macromedia, Metrowerks, Microsoft, Palm Computing, Quark, SPSS and Wolfram (see related supporting quote sheet).

Availability

Mac OS X will be rolled out over a 12 month period. Macintosh developers have already received two pre-releases of the software, and they will receive another pre-release later this month—the first to incorporate Aqua. Developers will receive the final “beta” pre-release this spring. Mac OS X will go on sale as a shrink-wrapped software product this summer, and will be pre-loaded as the standard operating system on all Macintosh computers beginning in early 2001. Mac OS X is designed to run on all Apple Macintosh computers using PowerPC G3 and G4 processor chips, and requires a minimum of 64 MB of memory.

[this-week-in-rust]

This Week in Rust 550

Hello and welcome to another issue of This Week in Rust! Rust is a programming language empowering everyone to build reliable and efficient software. This is a weekly summary of its progress and community. Want something mentioned? Tag us at @ThisWeekInRust on X(formerly Twitter) or @ThisWeekinRust on mastodon.social, or send us a pull request. Want to get involved? We love contributions.

This Week in Rust is openly developed on GitHub and archives can be viewed at this-week-in-rust.org. If you find any errors in this week's issue, please submit a PR.

Updates from Rust Community

Foundation

Welcoming Rust-C++ Interoperability Engineer Jon Bauman to the Rust Foundation Team

RustNL 2024

Visual Application Design for Rust - Rik Arends

ThRust in Space: Initial Momentum - Michaël Melchiore

Arc in the Linux Kernel - Alice Ryhl

Making Connections - Mara Bos

Replacing OpenSSL One Step at a Time - Joe Birr-Pixton

Fortifying Rust's FFI with Enscapsulated Functions - Leon Schuermann

Oxidizing Education - Henk Oordt

Postcard: An Unreasonably Effective Tool for Machine to Machine Communication - James Munns

Introducing June - Sophia Turner

Robius: Immersive and Seamless Multiplatform App Development in Rust - Kevin Boos

Compression Carcinized: Implementing zlib in Rust - Folkert de Vries

K23: A Secure Research OS Running WASM - Jonas Kruckenberg

Async Rust in Embedded Systems with Embassy - Dario Nieuwenhuis

Xilem: Let's Build High Performance Rust UI - Raph Levien

Rust Poisoning My Wrist for Fun - Ulf Lilleengen

Type Theory for Busy Engineers - Niko Matsakis

Newsletters

This Month in Rust GameDev #51 - May 2024

Project/Tooling Updates

Enter paradis — A new chapter in Rust's parallelism story

Tiny Glade, VJ performances, and 2d lighting

Diesel 2.2.0

Pigg 0.1.0

git-cliff 2.3.0 is released! (highly customizable changelog generator)

Observations/Thoughts

The borrow checker within

Don't Worry About Lifetimes

rust is not about memory safety

On Dependency Usage in Rust

Context Managers: Undroppable Types for Free

Rust and dynamically-sized thin pointers

Rust is for the Engine, Not the Game

[audio] Thunderbird - Brendan Abolivier, Software Engineer

Rust Walkthroughs

Build with Naz : Rust typestate pattern

How to build a plugin system in Rust

Forming Clouds

Rust error handling: Option & Result

Let's build a Load Balancer in Rust - Part 3

The Ultimate Guide to Rust Newtypes

Miscellaneous

Highlights from "I spent 6 years developing a puzzle game in Rust and it just shipped, AMA"

Crate of the Week

This week's crate is layoutparser-ort, a simplified port of LayoutParser for ML-based document layout element detection.

Despite there being no suggestions, llogiq is reasonably happy with his choice. Are you?

No matter what your answer is, please submit your suggestions and votes for next week!

Calls for Testing

An important step for RFC implementation is for people to experiment with the implementation and give feedback, especially before stabilization. The following RFCs would benefit from user testing before moving forward:

RFCs

No calls for testing were issued this week.

Rust

No calls for testing were issued this week.

Rustup

No calls for testing were issued this week.

If you are a feature implementer and would like your RFC to appear on the above list, add the new call-for-testing label to your RFC along with a comment providing testing instructions and/or guidance on which aspect(s) of the feature need testing.

Call for Participation; projects and speakers

CFP - Projects

Always wanted to contribute to open-source projects but did not know where to start? Every week we highlight some tasks from the Rust community for you to pick and get started!

Some of these tasks may also have mentors available, visit the task page for more information.

No Calls for participation in projects were submitted this week.

If you are a Rust project owner and are looking for contributors, please submit tasks here or through a PR to TWiR or by reaching out on X (Formerly twitter) or Mastodon!

CFP - Events

Are you a new or experienced speaker looking for a place to share something cool? This section highlights events that are being planned and are accepting submissions to join their event as a speaker.

Scientific Computing in Rust 2024 | Closes 2024-06-14 | online | Event date: 2024-07-17 - 2024-07-19

Rust Ukraine 2024 | Closes 2024-07-06 | Online + Ukraine, Kyiv | Event date: 2024-07-27

Conf42 Rustlang 2024 | Closes 2024-07-22 | online | Event date: 2024-08-22

If you are an event organizer hoping to expand the reach of your event, please submit a link to the website through a PR to TWiR or by reaching out on X (Formerly twitter) or Mastodon!

Updates from the Rust Project

308 pull requests were merged in the last week

-Znext-solver: eagerly normalize when adding goals

fn_arg_sanity_check: fix panic message

add --print=check-cfg to get the expected configs

add -Zfixed-x18

also InstSimplify &raw*

also resolve the type of constants, even if we already turned it into an error constant

avoid unwrap diag.code directly in note_and_explain_type_err

check index value <= 0xFFFF_FF00

coverage: avoid overflow when the MC/DC condition limit is exceeded

coverage: optionally instrument the RHS of lazy logical operators

coverage: rename MC/DC conditions_num to num_conditions

create const block DefIds in typeck instead of ast lowering

do not equate Const's ty in super_combine_const

do not suggest unresolvable builder methods

a small diagnostic improvement for dropping_copy_types

don't recompute tail in lower_stmts

don't suggest turning non-char-literal exprs of ty char into string literals

enable DestinationPropagation by default

fold item bounds before proving them in check_type_bounds in new solver

implement needs_async_drop in rustc and optimize async drop glue

improve diagnostic output of non_local_definitions lint

make ProofTreeBuilder actually generic over Interner

make body_owned_by return the Body instead of just the BodyId

make repr(packed) vectors work with SIMD intrinsics

make lint: lint_dropping_references lint_forgetting_copy_types lint_forgetting_references give suggestion if possible

omit non-needs_drop drop_in_place in vtables

opt-in to FulfillmentError generation to avoid doing extra work in the new solver

reintroduce name resolution check for trying to access locals from an inline const

reject CVarArgs in parse_ty_for_where_clause

show files produced by --emit foo in json artifact notifications

silence some resolve errors when there have been glob import errors

stop using translate_args in the new solver

support mdBook preprocessors for TRPL in rustbook

test codegen for repr(packed,simd) → repr(simd)

tweak relations to no longer rely on TypeTrace

unroll first iteration of checked_ilog loop

uplift {Closure,Coroutine,CoroutineClosure}Args and friends to rustc_type_ir

use parenthetical notation for Fn traits

add some more specific checks to the MIR validator

miri: avoid making a full copy of all new allocations

miri: fix "local crate" detection

don't inhibit random field reordering on repr(packed(1))

avoid checking the edition as much as possible

increase vtable layout size

stabilise IpvNAddr::{BITS, to_bits, from_bits} (ip_bits)

stabilize custom_code_classes_in_docs feature

stablize const_binary_heap_constructor

make std::env::{set_var, remove_var} unsafe in edition 2024

implement feature integer_sign_cast

NVPTX: avoid PassMode::Direct for args in C abi

genericize ptr::from_raw_parts

std::pal::unix::thread fetching min stack size on netbsd

add an intrinsic for ptr::metadata

change f32::midpoint to upcast to f64

rustc-hash: replace hash with faster and better finalized hash

cargo test: Auto-redact elapsed time

cargo add: Avoid escaping double-quotes by using string literals

cargo config: Ensure --config net.git-fetch-with-cli=true is respected

cargo new: Dont say were adding to a workspace when a regular package is in root

cargo toml: Ensure targets are in a deterministic order

cargo vendor: Ensure sort happens for vendor

cargo: allows the default git/gitoxide configuration to be obtained from the ENV and config

cargo: adjust custom err from cert-check due to libgit2 1.8 change

cargo: skip deserialization of unrelated fields with overlapping name

clippy: many_single_char_names: deduplicate diagnostics

clippy: add needless_character_iteration lint

clippy: deprecate maybe_misused_cfg and mismatched_target_os

clippy: disable indexing_slicing for custom Index impls

clippy: fix redundant_closure suggesting incorrect code with F: Fn()

clippy: let non_canonical_impls skip proc marco

clippy: ignore array from deref_addrof lint

clippy: make str_to_string machine-applicable

rust-analyzer: add Function::fn_ptr_type(…) for obtaining name-erased function type

rust-analyzer: don't mark #[rustc_deprecated_safe_2024] functions as unsafe

rust-analyzer: enable completions within derive helper attributes

rust-analyzer: fix container search failing for tokens originating within derive attributes

rust-analyzer: fix diagnostics clearing when flychecks run per-workspace

rust-analyzer: only generate snippets for extract_expressions_from_format_string if snippets are supported

rustfmt: collapse nested if detected by clippy

rustfmt: rustfmt should not remove inner attributes from inline const blocks

rustfmt: rust rewrite check_diff (Skeleton)

rustfmt: use with_capacity in rewrite_path

Rust Compiler Performance Triage

A quiet week; we did have one quite serious regression (#115105, "enable DestinationPropagation by default"), but it was shortly reverted (#125794). The only other PR identified as potentially problematic was rollup PR #125824, but even that is relatively limited in its effect.

Triage done by @pnkfelix. Revision range: a59072ec..1d52972d

3 Regressions, 5 Improvements, 6 Mixed; 4 of them in rollups 57 artifact comparisons made in total

Full report here

Approved RFCs

Changes to Rust follow the Rust RFC (request for comments) process. These are the RFCs that were approved for implementation this week:

No RFCs were approved this week.

Final Comment Period

Every week, the team announces the 'final comment period' for RFCs and key PRs which are reaching a decision. Express your opinions now.

RFCs

Change crates.io policy to not offer crate transfer mediation

Tracking Issues & PRs

Rust

[disposition: merge] Allow constraining opaque types during subtyping in the trait system

[disposition: merge] TAIT decision on "may define implies must define"

[disposition: merge] Stabilize Wasm relaxed SIMD

Cargo

No Cargo Tracking Issues or PRs entered Final Comment Period this week.

Language Team

No Language Team RFCs entered Final Comment Period this week.

Language Reference

No Language Reference RFCs entered Final Comment Period this week.

Unsafe Code Guidelines

No Unsafe Code Guideline RFCs entered Final Comment Period this week.

New and Updated RFCs

No New or Updated RFCs were created this week.

Upcoming Events

Rusty Events between 2024-06-05 - 2024-07-03 🦀

Virtual

2024-06-05 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

2024-06-06 | Virtual (Tel Aviv, IL) | Code Mavens

Rust Maven Workshop: Your first contribution to an Open Source Rust project

2024-06-06 | Virtual (Berlin, DE) | OpenTechSchool Berlin + Rust Berlin

Rust Hack and Learn | Mirror: Rust Hack n Learn Meetup

2024-06-09 | Virtual (Tel Aviv, IL) | Code Mavens

Rust Maven Workshop: GitHub pages for Rust developers (English)

2024-06-11 | Virtual (Dallas, TX, US) | Dallas Rust

Second Tuesday

2024-06-12 | Virtual (Cardiff, UK)| Rust and C++ Cardiff

Rust for Rustaceans Book Club: Chapter 8 - Asynchronous Programming

2024-06-13 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2024-06-13 | Virtual (Nürnberg, DE) | Rust Nuremberg

Rust Nürnberg online

2024-06-16 | Virtual (Tel Aviv, IL) | Code Mavens

Workshop: Web development in Rust using Rocket (English)

2024-06-18 | Virtual (Washington, DC, US) | Rust DC

Mid-month Rustful

2024-06-19 | Virtual (Vancouver, BC, CA) | Vancouver Rust

Rust Study/Hack/Hang-out

2024-06-20 | Virtual (Berlin, DE) | OpenTechSchool Berlin + Rust Berlin

Rust Hack and Learn | Mirror: Rust Hack n Learn Meetup

2024-06-25 | Virtual (Dallas, TX, US)| Dallas Rust User Group

Last Tuesday

2024-06-27 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2024-07-02 | Virtual (Buffalo, NY) | Buffalo Rust Meetup

Buffalo Rust User Group

2024-07-03 | Virtual | Training 4 Programmers LLC

Build Web Apps with Rust and Leptos

2024-07-03 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

Europe

2024-06-05 | Hamburg, DE | Rust Meetup Hamburg

Rust Hack & Learn June 2024

2024-06-06 | Madrid, ES | MadRust

Introducción a Rust y el futuro de los sistemas DLT

2024-06-06 | Vilnius, LT | Rust Vilnius

Enjoy our second Rust and ZIG event

2024-06-06 | Wrocław, PL | Rust Wroclaw

Rust Meetup #37

2024-06-11 | Copenhagen, DK | Copenhagen Rust Community

Rust Hack Night #6: Discord bots

2024-06-11 | Paris, FR | Rust Paris

Paris Rust Meetup #69

2024-06-12 | Reading, UK | Reading Rust Workshop

Reading Rust Meetup

2024-06-18 | Frankfurt/Main, DE | Rust Frankfurt Meetup

Rust Frankfurt is Back!

2024-06-19 - 2024-06-24 | Zürich, CH | RustFest Zürich

RustFest Zürich 2024

2024-06-20 | Aarhus, DK | Rust Aarhus

Talk Night at Trifork

2024-06-25 | Gdańsk, PL | Rust Gdansk

Rust Gdansk Meetup #3

2024-06-27 | Berlin, DE | Rust Berlin

Rust and Tell - Title

2024-06-27 | Copenhagen, DK | Copenhagen Rust Community

Rust meetup #48 sponsored by Google!

North America

2024-06-08 | Somerville, MA, US | Boston Rust Meetup

Porter Square Rust Lunch, Jun 8

2024-06-11 | New York, NY, US | Rust NYC

Rust NYC Monthly Meetup

2024-06-12 | Detroit, MI, US | Detroit Rust

Detroit Rust Meet - Ann Arbor

2024-06-13 | Spokane, WA, US | Spokane Rust

Monthly Meetup: Topic TBD!

2024-06-17 | Minneapolis, MN US | Minneapolis Rust Meetup

Minneapolis Rust Meetup Happy Hour

2024-06-18 | San Francisco, CA, US | San Francisco Rust Study Group

Rust Hacking in Person

2024-06-20 | Seattle, WA, US | Seattle Rust User Group

Seattle Rust User Group Meetup

2024-06-26 | Austin, TX, US | Rust ATC

Rust Lunch - Fareground

2024-06-27 | Nashville, TN, US | Music City Rust Developers

Music City Rust Developers: Holding Pattern

Oceania

2024-06-14 | Melbourne, VIC, AU | Rust Melbourne

June 2024 Rust Melbourne Meetup

2024-06-20 | Auckland, NZ | Rust AKL

Rust AKL: Full Stack Rust + Writing a compiler for fun and (no) profit

2024-06-25 | Canberra, ACt, AU | Canberra Rust User Group (CRUG)

June Meetup

South America

2024-06-06 | Buenos Aires, AR | Rust en Español | Rust Argentina

Juntada de Junio

If you are running a Rust event please add it to the calendar to get it mentioned here. Please remember to add a link to the event too. Email the Rust Community Team for access.

Jobs

Please see the latest Who's Hiring thread on r/rust

Quote of the Week

Every PR is Special™

– Hieyou Xu describing being on t-compiler review rotation

Sadly, there was no suggestion, so llogiq came up with something hopefully suitable.

Please submit quotes and vote for next week!

This Week in Rust is edited by: nellshamrell, llogiq, cdmistman, ericseppanen, extrawurst, andrewpollack, U007D, kolharsam, joelmarcey, mariannegoldin, bennyvasquez.

Email list hosting is sponsored by The Rust Foundation

Discuss on r/rust

[kakurady]

My new Bosch dishwasher comes with a list of every Linux (the kernel) contributor.

All of them, over 182 pages. https://media3.bosch-home.com/Documents/9001496216_D.pdf

[atplblog]

Price: [price_with_discount] (as of [price_update_date] - Details) [ad_1] Description: USB 3.1 High Speed Transmission: High transmission speed for data-heavy applications and fast file transfer, read speed up to 430 MB/s, write speed up to 370 MB/s.Large Capacity: Store your whole world, store songs, documents, images, and videos, it can meet the demands of your work and study.OTG Connector: USB-C Cable / Connector, Directly connect the drive to your mobile phone and instantly access your files.Slim and Portable Design: Saving-space SSD is convenient for the user to carry.Shock-proof & Shatter-proof: High Strength Aluminum Alloy Casing, the surface of product has a higher body temperature during the use process because Aluminum alloy has the performance of quick heat conduction.Strong Compatibility: The USB3.1 is backward compatible with USB 2.0, supports TV, phone, tablet, camera, for PS4, for and other devices. Specification: Material: Aluminum AlloyDimensions: 10.5x3x1cmRead Speed Up to 430 MB/sWrite Speed Up to 370 MB/sInterface: USB 3.1Compatible with Windows XP/Vista/7/88.1/10, OS X 10.6, Linux Kernel 2.6Mobile Device Compatible with Android 5.0 And Above Devices That Support OTG Package Includes: 1x Portable SSD1x USB 3.1 Cable Note: Conversion: 1inch=2.54cm, 1cm=0.393inchPlease allow slightly 0-1cm difference due to manual measurement.Colors can appear different depending on light and how the listing is viewed.Thanks for your understanding and attention. Wish you a pleasant shopping experience! Usb 3.1 High Speed Transmission: High Transmission Speed For Data-Heavy Applications And Fast File Transfer, Read Speed Up To 430 Mb/S, Write Speed Up To 370 Mb/S. Large Capacity: Store Your Whole World, Store Songs, Documents, Images, And Videos, It Can Meet The Demands Of Your Work And Study. Otg Connector: Usb-C Cable / Connector, Directly Connect The Drive To Your Mobile Phone And Instantly Access Your Files. Slim And Portable Design: Saving-Space Ssd Is Convenient For The User To Carry. Shock-Proof & Shatter-Proof: High Strength Aluminum Alloy Casing, The Surface Of Product Has A Higher Body Temperature During The Use Process Because Aluminum Alloy Has The Performance Of Quick Heat Conduction. [ad_2]

[siliconsignalsblog]

Getting Started with AOSP: Build Custom Android Solutions

Want to see what it takes to build your own Android-based system? Regardless of whether you want to use custom hardware or embedded software, AOSP delivers a complete and adaptable resource. We’ll go over AOSP, its benefits, drawbacks and why it is slowly being adopted by smartphones, IoT devices and automotive platforms. 

What is AOSP (Android Open Source Project)? 

The Android Open Source Project is a repository of source code and documentation used to build the core Android operating system. It's open-source, meaning developers, OEMs, and businesses can freely access, modify, and build upon the platform to create custom Android distributions. 

While AOSP contains the base OS, it does not include Google’s proprietary apps and services (like Gmail, Google Play, and Maps)—those are part of Google Mobile Services (GMS), which requires a license. AOSP represents the raw and adaptable side of Android, giving developers control over features, UI, and performance. 

Why Developers and OEMs Choose AOSP 

High Customizability 

One of the biggest benefits of AOSP is its deep customization capabilities. Developers can tweak system behavior, design new UIs, and tailor Android for specific hardware or use cases, such as kiosks, tablets, or IoT devices. 

No Licensing Costs 

Since AOSP is free, it’s ideal for companies aiming to build custom Android-based products without relying on Google’s ecosystem. This is especially helpful for industries like healthcare, education, or defense, where Google services might not be required or allowed. 

Hardware Flexibility 

AOSP allows adaptation across a wide range of hardware—from smartphones and tablets to embedded systems, automotive solutions, wearables, and industrial IoT devices. This makes it a top choice for OEMs and BSP providers. 

Strong Developer Community 

With thousands of contributors, documentation, forums, and GitHub repos, AOSP offers rich community support. This collective innovation drives constant improvement and makes troubleshooting and development smoother. 

Key Challenges of AOSP 

Despite its strengths, AOSP comes with its own set of challenges: 

No Native Google Apps 

Devices using AOSP without GMS won’t have access to the Google Play Store or essential apps like YouTube, Gmail, and Google Maps. Licensing GMS is necessary for these features, unlike in closed ecosystems like iOS, where services are pre-integrated. 

Hardware Compatibility 

When building custom Android BSPs, developers often need to work on hardware abstraction layers (HALs), drivers, and kernels to ensure full compatibility with chipsets and peripherals—something that requires deep embedded expertise. 

OS Fragmentation 

Since anyone can fork AOSP, there’s significant fragmentation across Android devices, which can complicate update cycles and security patching. Closed-source systems like iOS maintain consistency but sacrifice flexibility. 

Comparing AOSP to Other Platforms 

iOS 

Pros: Controlled environment, seamless hardware-software integration. 

Cons: Limited developer freedom; closed source prevents OS-level customizations. 

Other Linux-Based OSs (e.g., Tizen, KaiOS) 

Pros: Designed for specific devices like feature phones or smart TVs. 

Cons: Limited community support, fewer apps, and low flexibility compared to AOSP. 

Market Forecast: Why AOSP is the Future 

Dominance in Emerging Markets 

Android, powered by AOSP, leads in affordability and reach. Custom builds allow for cost-effective smartphones tailored for budget-conscious regions like Southeast Asia, Africa, and Latin America. 

Rise of Android Automotive & Embedded Systems 

With AOSP at its core, Android Automotive is gaining traction in vehicles. Similarly, embedded devices, kiosks, and industrial IoT systems benefit from lightweight, modular AOSP deployments. 

Tailored Enterprise & Industry Solutions 

Companies are creating Android-based devices for education, healthcare, logistics, and retail. These devices are powered by custom Android BSPs built on AOSP, offering greater control, security, and reliability. 

IoT & Wearables Growth 

From smartwatches to home hubs, AOSP’s flexibility makes it the go-to OS for IoT. Although Google shifted focus from Android Things, developers still rely on AOSP for headless devices and custom builds in the IoT space. 

Getting Started with AOSP 

To explore AOSP, start by visiting Google’s official repositories and AOSP documentation. Participate in forums like XDA Developers, Reddit, and GitHub discussions to find solutions and engage with the broader developer ecosystem. 

Looking for an experienced team to help you build, port, or customize AOSP for your embedded product? 

At Silicon Signals, we specialize in Android BSP development, AOSP customization, driver integration, and OS porting for a wide range of hardware platforms. From Android 14 BSPs to fully tailored Android stacks for industrial and commercial devices—we’ve got you covered. 

Ready to launch your custom Android solution? Contact Our Engineers for a free consultation 

Connect us on info@siliconsignals.io 

[bliiot]

Features and Applications of Debian/Arch Linux ARM OS

1. Core Features of Debian ARM

(1) Stable and Reliable Foundation

Community-maintained: Developed by global contributors without commercial influence

Extended support cycle: 5-year security updates for each stable release (extendable to 10 years via LTS project)

Rigorous quality control: Packages undergo strict stability testing before entering stable repos

(2) Broad Hardware Compatibility

Supports full ARMv7/ARMv8 architectures from Cortex-A7 to A78

Officially maintains ports for over 20 single-board computers (including all Raspberry Pi models)

(3) Lightweight Design

Minimal installation requires only ~128MB RAM

Offers systemd-free Devuan branch alternative

(4) Software Ecosystem

Includes over 59,000 precompiled packages

Provides newer software versions via backports repository

2. Typical Applications of Debian ARM

(1) Server Domain

Low-power ARM servers (e.g. AWS Graviton instances)

Network infrastructure (routers, firewalls)

(2) Embedded Systems

Industrial control equipment (requiring long-term stable operation)

Medical devices (compliant with IEC 62304 standard)

(3) Education & Research

Computer architecture teaching platforms

Scientific computing cluster nodes

3. Core Features of Arch Linux ARM

(1) Rolling Release Model

Provides latest software versions (kernel/toolchain etc.)

Daily synchronization with upstream Arch Linux updates

(2) Ultimate Customization

Build from base system according to needs

Supports custom kernel compilation (e.g. enabling specific CPU features)

(3) Community Support

Active AUR (Arch User Repository)

Detailed Wiki documentation

(4) Performance Optimization

Default ARM-specific compilation optimizations

NEON instruction set acceleration support

4. Typical Applications of Arch Linux ARM

(1) Development Platform

Embedded development testing environment

Kernel/driver development platform

(2) Enthusiast Devices

Customized smart home hubs

Portable development workstations

(3) Cutting-edge Technology Testing

New architecture validation (e.g. ARMv9)

Machine learning framework experimentation

5. Comparative Summary

6. Usage Recommendations

Choose Debian ARM: For mission-critical systems, industrial control requiring long-term stability

Choose Arch Linux ARM: For latest software features, hardware R&D or deep customization

[hiringjournal]

How to Hire a Linux Kernel Developer: Skills, Experience & Interview Questions

Linux powers everything from web servers to embedded devices, and its core lies at Linux Kernel - a crucial layer that demands deep expertise for modification, maintenance, and optimization. For tech companies that are building high-performance systems, device drivers, or custom operating environments the decision to hire software developers proficient in Linux Kernel can be a strategic move. 

But kernel development is a niche skill and to hire the right developer requires you to know what to look for and to ask the right questions. In this article, we will cover how you can do it. 

Finding the Right Low-Level Expert for High-Performance Systems

Kernel engineers bridge the gap between user-level apps and hardware by working at the lowest software layer. Frequently, when hiring Linux kernel developers, you often want to:

Patch or modify the kernel to work with particular hardware.

Create or troubleshoot device drivers.

Boost system efficiency or lower delay.

Assure mission-critical systems' security and stability.

This isn't how applications are usually developed. It calls for a solid understanding of memory management, operating systems, and the nuances of C programming.

Key Skills to Look For

Give these crucial areas top priority while vetting applicants:

Proficiency in C: Since C is used for nearly all kernel development, in-depth expertise is non negotiable.

Kernel module experience: Applicants should be able to write, compile, and load kernel modules.

Tools for Debugging and Profiling: It's crucial to be familiar with programs like gdb, perf, and ftrace.

Knowledge of OS Internals: Key ideas include scheduling, memory management, and I/O systems.

Version Control & Patch Submissions: It is highly advantageous to contribute to open-source projects or the mainline Linux kernel.

A candidate's ability to communicate effectively across time zones and accurately document their work is also essential if you're looking to hire remote developers. 

Where to Find Talent

Using conventional methods to hire Linux kernel developers isn't always simple. These engineers frequently contribute to specialized communities like Git repositories and kernel mailing groups, or they work on open-source projects.

Some tech companies decide to collaborate with organizations that focus on low-level software development or embedded technologies. Others seek to hire programmers who possess a solid foundation in C and OS, then train them in kernel-specific techniques.

Interview Questions to Ask

After you've found a good applicant, probe further with focused questions:

What distinguishes user space from kernel space?

How would a production system's kernel panic be debugged?

Could you describe the Linux kernel's memory allocation mechanism?

Have you submitted bug fixes or patches to the mainline kernel?

How are dependencies between kernel modules managed?

What function does the Linux kernel's scheduler serve?

Asking them to describe a recent kernel-related project, including its objectives, tools, and methods for testing and validating their work, is another option.

Summing Up

You must know exactly what your system needs and what kernel experience will provide it in order to hire Linux kernel engineers. The correct hire adds dependability, speed, and profound technical understanding to everything from driver creation to system optimization.

These developers are essential to tech companies creating scalable and secure infrastructure. Whether you're looking to hire remote developers or in-house developers, a careful, skills-based strategy can help you find the best fit.

[featuresopensource]

Features of the Linux Operating System

The Linux operating system is one of the most popular and influential open-source platforms in the computing world today. Developed originally by Linus Torvalds in 1991, Linux has evolved from a modest personal project into a powerful, flexible, and secure operating system used across various devices and environments—from smartphones and personal computers to servers, supercomputers, and embedded systems. Its widespread adoption and strong community support stem from a range of compelling features. This essay explores the key features of Linux that make it a preferred choice among developers, system administrators, and enterprises.

1. Open Source and Free

One of the most significant features of Linux is that it is open source and free to use. The Linux kernel and most distributions (or "distros") are released under the GNU General Public License (GPL), which allows users to freely access, modify, and distribute the source code. This openness fosters a culture of collaboration and innovation. Users and developers can customize the operating system according to their needs, fix bugs, or even develop their own versions of the OS.

This model contrasts with proprietary systems like Microsoft Windows or macOS, where source code is closed, and licensing fees are required. With Linux, individuals, educational institutions, startups, and large enterprises can benefit from a cost-effective, highly customizable operating system without recurring software licensing costs.

2. Multiuser Capability

Linux is a true multiuser operating system. This means that multiple users can access the system's resources—such as memory, CPU, and storage—at the same time without interfering with each other. Each user has a separate account with specific permissions and access controls. The system's security and file permission structures ensure that one user's data is isolated from another's, making it ideal for shared environments like servers and academic labs.

This feature is particularly valuable in enterprise and hosting environments, where multiple clients or departments may share a single server.

3. Multitasking

Linux supports robust multitasking, allowing multiple processes to run simultaneously without affecting each other. It can handle several applications at once—like editing documents, browsing the web, downloading files, and compiling code—without slowing down. The system's kernel efficiently manages CPU time and prioritizes tasks to ensure smooth operation even under heavy load.

This makes Linux suitable for both everyday use and high-performance environments, such as data centers and cloud computing platforms.

4. Portability

Linux is highly portable, meaning it can run on a wide variety of hardware platforms. Whether it's a personal computer, a mobile device, a mainframe, or an embedded system, there's likely a Linux version available for it. Its architecture-neutral design allows the Linux kernel to be compiled for nearly any processor, making it a dominant force in diverse computing ecosystems.

For example, Android, the most widely used mobile OS, is based on the Linux kernel. Linux is also the go-to choice for Raspberry Pi and other development boards used in robotics, automation, and IoT projects.

5. Stability and Reliability

Linux is known for its stability and reliability. Systems running Linux can operate for years without needing a reboot. Many servers running on Linux have uptimes that span months or even years. The system doesn’t slow down over time due to memory leaks or fragmentation as is common with some other operating systems.

Because of this stability, Linux is widely used for mission-critical applications such as web servers, financial systems, and government infrastructure. Downtime in such systems can lead to significant losses, and Linux helps minimize that risk.

6. Security

Security is a key feature of Linux. It uses a permission-based structure, where each file and process has an associated owner and set of permissions (read, write, execute). This ensures that unauthorized users cannot access or modify files they do not own. Additionally, Linux supports user roles, firewalls (like iptables and nftables), and strong authentication methods.

Since Linux is open source, vulnerabilities can be quickly identified and patched by the global community. Linux distributions frequently release security updates, and administrators can automate patch management using package managers. Advanced security features like SELinux (Security-Enhanced Linux) provide mandatory access controls and fine-grained security policies.

7. Flexibility and Customization

One of Linux’s most praised attributes is its flexibility. Users can choose from numerous distributions such as Ubuntu, Fedora, Debian, Arch Linux, and CentOS, each tailored for different purposes. Whether you need a minimal install for a lightweight IoT device or a full-featured desktop environment, Linux offers something for everyone.

Additionally, users can choose from different desktop environments (e.g., GNOME, KDE, Xfce) and window managers, tweak kernel settings, or even build a Linux system from scratch using tools like Linux From Scratch (LFS).

This level of customization is unparalleled and allows for an efficient system setup optimized for specific use cases.

8. Command Line Interface (CLI)

Linux boasts a powerful command-line interface, which provides users with complete control over the system. While graphical interfaces are available and user-friendly, the CLI is preferred by system administrators, developers, and power users for its speed, efficiency, and scripting capabilities.

The shell (like Bash, Zsh, or Fish) allows users to automate tasks, manage system processes, install software, and configure system settings. Bash scripting is a powerful tool for creating automated workflows, monitoring systems, and managing large-scale infrastructure.

9. Software Package Management

Linux uses package management systems to simplify software installation, updates, and removal. Each distribution has its own package manager (e.g., APT for Debian-based systems, YUM/DNF for Red Hat-based systems, Pacman for Arch Linux). These tools handle dependencies, download necessary files, and keep the system up to date.

Additionally, universal package formats like Snap, Flatpak, and AppImage offer cross-distribution compatibility and sandboxing, improving both convenience and security.

10. Community Support and Documentation

Linux has a vibrant global community of users, developers, and enthusiasts who contribute to its growth. Online forums, wikis, IRC channels, mailing lists, and websites like Stack Overflow and Reddit provide support and troubleshooting help. Most distributions maintain extensive documentation, making it easy for users to learn and resolve issues on their own.

This culture of collaboration not only makes Linux accessible to beginners but also ensures that it continually evolves in response to user needs.

11. Efficient Resource Usage

Linux is highly efficient in managing system resources. It can run on both high-end servers and low-spec hardware with minimal RAM and processing power. This makes it an excellent choice for reviving older computers or running headless servers where performance and efficiency are key.

Moreover, Linux does not require frequent reboots, uses less disk space, and has fewer background processes, reducing overhead and maximizing performance.

12. Support for Programming and Development

Linux is a developer-friendly operating system. It comes preloaded with essential programming tools such as GCC (GNU Compiler Collection), make, gdb, and numerous text editors like Vim, Nano, and Emacs. It also supports modern development environments and languages like Python, Java, C++, Node.js, Ruby, and Rust.

Because of its open nature and access to core components, Linux is often the platform of choice for software development, web development, DevOps, and system programming.

13. Networking and Server Capabilities

Linux is exceptionally strong in networking and server management. It includes built-in tools for configuring networks, monitoring traffic, and managing users and services. Common servers—such as Apache, Nginx, MySQL, Samba, FTP, and SSH—run seamlessly on Linux.

Its performance, security, and reliability make it the most popular operating system for web hosting, cloud computing, and container orchestration tools like Docker and Kubernetes.

Conclusion

Linux is not just an operating system; it's a robust ecosystem shaped by community, transparency, and freedom. Its features—ranging from open-source access and strong security to multitasking, resource efficiency, and rich customization—make it a powerful tool for a wide range of applications. Whether you're a home user, a developer, a systems administrator, or an enterprise, Linux offers a stable, secure, and scalable platform to build upon.

As technology continues to advance and the demand for open, secure, and high-performance systems grows, Linux’s relevance is only set to increase. Its adaptability, community-driven development, and strong foundation ensure that it will remain a cornerstone of modern computing for years to come.

[774]

Linux kernel development boss Linus Torvalds has admitted his own “pure incompetence” led him to forget to deliver version 6.14 of the project. Torvalds usually delivers new Linux kernel release candidates and full releases on Sunday afternoon, and documents each with a post. If he is traveling for work or pleasure, he usually gives advance notice so penguinistas don’t worry if his posts and releases don’t appear at the usual time. His Sunday March 16th post contained no advice of unusual posting times, instead promising “I expect to release the final 6.14 next weekend unless something very surprising happens.” Sunday March 23rd came and went without a post. “I'd love to have some good excuse for why I didn't do the 6.14 release yesterday on my regular Sunday afternoon release schedule,” he wrote on Monday the 24th. “I'd like to say that some important last-minute thing came up and delayed things,” he added “But no. It's just pure incompetence,” he confessed. “Because absolutely nothing last-minute happened yesterday, and I was just clearing up some unrelated things in order to be ready for the merge window. And in the process just entirely forgot to actually ever cut the release. D'oh.”

Linus Torvalds forgot to release Linux 6.14 for a day • The Register