AI Skeptics: The AI Blue Wave (with Tom Adams)

Math Babe
mathbabe.org
2026-11-09 07:46:02
In which we discuss the market reaction to the election, how AI is taking over lawyering, and the new NY AI regs: Apple Spotify YouTube...
Original Article

Home > Uncategorized > AI Skeptics: The AI Blue Wave (with Tom Adams)

In which we discuss the market reaction to the election, how AI is taking over lawyering, and the new NY AI regs:

Apple

Spotify

YouTube

Categories: Uncategorized

Comments (0) Trackbacks (0) Leave a comment Trackback

  1. No comments yet.
  1. No trackbacks yet.

Leave a Reply

Your email address will not be published. Required fields are marked *

Altar II Keyboard on Kickstarter

Daring Fireball
www.kickstarter.com
2026-11-10 15:59:25
Electronic Materials Office is the brainchild of Andrew Emerson. Back in 2023 he launched the Altar I, a rather distinctive mechanical keyboard. Much thinner than most, very opinionated in its industrial design and keycap typography. I got one and I don’t regret it, but there was too much I didn’t l...
Original Article

Japanese furniture giant Nitori says hackers stole 37.6M customer records

Bleeping Computer
www.bleepingcomputer.com
2026-11-10 15:54:55
Nitori, a major Japanese furniture and home accessories retailer, discovered that an attacker accessed a system on its network and may have stolen 37.62 million customer records. [...]...
Original Article

Japanese furniture giant Nitori says hackers stole 37.6M customer records

Nitori, a major Japanese furniture and home accessories retailer, discovered that an attacker accessed a system on its network and may have stolen 37.62 million customer records.

The intrusion was detected on November 6, and the company blocked the unauthorized access. However, an investigation into the incident revealed that the attacker likely had access to the system since mid-October.

Nitori, often called the “IKEA of Japan,” is a major furniture and home furnishings retailer that operates 879 stores in Japan and another 219 stores across China, South Korea, Taiwan, Thailand, Singapore, and Hong Kong. The firm has an annual revenue of $5.8 billion.

image

According to the company's notification, the incident impacts individual customers, corporate members, and non-members who placed orders through official Nitori stores and online shops.

“On November 6, 2026, we confirmed unauthorized access by a third party to a system managed by our company,” [machine translated] the company says in the notification

“Our investigation to date has revealed that up to 37.62 million records of personal information held on our servers may have been leaked externally.”

The potentially exposed information may include the following data types:

  • Individual members and purchasers: Membership numbers, names, email addresses, postal addresses, telephone numbers, dates of birth, and gender.
  • Corporate members: Membership numbers, company names, department names, representatives’ names, company addresses and telephone numbers, and contact persons’ names, email addresses, and telephone numbers.
  • Online orders: Order information for purchases through Nitori Net and official Nitori shops on e-commerce marketplaces.

The company specified that account passwords of registered members and credit card information were not exposed in this incident.

Nitori says it promptly blocked the attacker’s access, addressed vulnerabilities in its systems, and strengthened threat monitoring to prevent similar incidents in the future.

The company warned potentially impacted customers that the compromised information could be leveraged in phishing attacks and scamming attempts against, and urged them to exercise caution.

The announcement emphasizes that Nitori will never ask customers for their password, credit card number, or PIN by email or in phone conversations.

Nitori has informed Japan’s Personal Information Protection Commission, the police, and other relevant authorities, and has promised to notify affected customers directly by email or post.

BleepingComputer has contacted Nitori with questions about the incident, and we will update this post when we get a reply.

article image

Uncover email threats your existing defenses may miss.

Adaptive Security's AI agents analyze email intent, context, and behavior to uncover phishing, business email compromise, and invoice fraud.

See what's getting through with a 14-day read-only scan of Microsoft 365 or Google Workspace, with no MX changes.

Start your free email security scan.

llm-gemini 0.36

Simon Willison
simonwillison.net
2026-11-10 15:09:44
Release: llm-gemini 0.36 Gemini 4 Carbon was announced two weeks ago for "a subset of cyber defenders", but today it's available to everyone else. This is Google's best ever Gemini, priced at $2/million input and $10/million output at launch (that's GPT-6.1 Sol / Claude Sonnet 5.5 prices) bu...
Original Article

Gemini 4 Carbon was announced two weeks ago for "a subset of cyber defenders", but today it's available to everyone else .

This is Google's best ever Gemini, priced at $2/million input and $10/million output at launch (that's GPT-6.1 Sol / Claude Sonnet 5.5 prices) but scheduled to double in price to $4/$20 on December 1st (same as Opus 5.5).

Here are three pelicans for the low, medium and high thinking efforts (it defaults to medium). This is the pelican I got for high:

A lovely pelican. Looks like it has a monocle on. Nice elegant sailor hat with a blue bow. Basket and fish. Funky but workable bicycle design. Pleasing use of gradients.

Gemini pelicans have all been great for a while now, so I also tested it out using Google's Antigravity IDE with a prompt I first tried with Claude Fable 5.2 yesterday :

Make a three js animation where yonkers stands up as a big mech (cool stand up motion) and stomps around manhattan and queens and Brooklyn, use openstreetmap mapping data

Here's the HTML result (I had to prompt "build that into a standalone HTML file" to get a version with no external dependencies). I then screen-captured that as a video:

Update : Huh, just saw this on YouTube :

Using Google Antigravity’s /swarm feature, Carbon built an open-world 3D game where you explore Google’s Mountain View campus as a pelican riding a GBike — coordinating subagents to model 3D assets in Blender from Omni and Nano Banana references, build the browser game in Three.js with WebGL shaders, and pair procedural Web Audio sound effects with Lyria music.

Microsoft releases Windows 10 KB5131096 extended security update

Bleeping Computer
www.bleepingcomputer.com
2026-11-10 15:04:36
Microsoft released the Windows 10 KB5131096 extended security update, which includes this month's November 2026 Patch Tuesday fixes and a few bug fixes and changes. [...]...
Original Article

Windows 10

Microsoft released the Windows 10 KB5131096 extended security update, which includes this month's November 2026 Patch Tuesday fixes and a few bug fixes and changes.

If you are running Windows 10 Enterprise LTSC or are enrolled in the ESU program , you can install this update as normal by going to Settings, clicking Windows Update, and manually running a 'Check for Updates.'

Windows 10 KB5131096 update
Windows 10 KB5131096 update
Source: BleepingComputer

After installing this update, Windows 10 will be updated to build 19045.7846, and Windows 10 Enterprise LTSC 2021 will be updated to build 19044.7846.

image

What's new in Windows 10 KB5131096

Microsoft no longer releases new features for Windows 10, and the KB5131096 update mainly includes security updates and bug fixes.

The update also includes fixes released as part of today's November 2026 Patch Tuesday , which addressed 1,235 vulnerabilities across Microsoft's products, including one actively exploited Outlook zero-day flaw.

The complete list of fixes and changes in KB5131096 is below:

  • [Date and Time] This update adjusts daylight saving time (DST) rules for Cuba for the extended 2026-2027 DST period. Cuba remains on UTC-04:00 and doesn't observe the November 2026 and March 2027 transitions. It returns to UTC-05:00 in November 2027 and resumes its regular seasonal schedule in 2028.

  • [Printing] - Fixed: Adding a printer published in Active Directory through Settings > Bluetooth & devices > Printers & scanners > Add device might fail with error 87, "The parameter is incorrect." This issue was introduced by the October 2026 update and does not generally affect existing printers or printing.

  • [Remote Desktop]

    • Fixed: The “Specify thumbprints of certificates representing trusted .rdp publishers” policy could not be configured successfully through Microsoft Intune.
    • Fixed: Remote Desktop shadow connections might fail with an “Unspecified error” on Windows Server 2016 and Windows Server 2012 R2 after installing the October 14, 2026, update.

  • [Windows PowerShell] This update strengthens security for PowerShell script signing and signature verification by introducing stricter encoding validation. As a result, scripts containing invalid UTF-8 encoding might fail signature validation, even if they were previously accepted. To resolve this issue, review the affected scripts, save them using valid UTF-8 encoding with a byte order mark (BOM), and sign them again. For further guidance, see Encoding Guidance for Signed PowerShell Scripts .

Microsoft says it has now resolved all known issues affecting USB Audio Class 1.0 devices introduced by the September 2026 Windows security updates.

The problems caused some devices to stop producing audio, fail to start with Code 10 errors, or experience unresponsive volume controls and sound settings.

Microsoft previously released an emergency out-of-band update on September 14 to fix issues affecting 8-channel and 3D audio modes.

The remaining audio issues have now been fixed in today's Windows 10 update.

article image

Uncover email threats your existing defenses may miss.

Adaptive Security's AI agents analyze email intent, context, and behavior to uncover phishing, business email compromise, and invoice fraud.

See what's getting through with a 14-day read-only scan of Microsoft 365 or Google Workspace, with no MX changes.

Start your free email security scan.

Searching for pedagogical materials on memory models

Lobsters
lobste.rs
2026-11-10 14:51:19
Hi folks, I'm working on some supplementary materials for a course I'm TAing, my university's version of operating systems, that involves students developing an OS targeting a Raspberry Pi 3B+. One of the topics I'm trying to get at is strong and weak memory models (and why ARM has so many weird dat...
Original Article

Hi folks,

I'm working on some supplementary materials for a course I'm TAing, my university's version of operating systems, that involves students developing an OS targeting a Raspberry Pi 3B+. One of the topics I'm trying to get at is strong and weak memory models (and why ARM has so many weird data/instruction buffer synchronization things students have to do when writing an MMU), so if you have any excellent example articles/passages/blogs on memory models that have helped you, please comment them so I can take a look!

Thanks!

Memory Safety Bugs in Rust Standard Library

Lobsters
forge-blog.github.io
2026-11-10 14:44:50
Comments...
Original Article

Microsoft’s FORGE Lab found several memory safety issues in Rust’s standard library ( std and core ), including cases where code written entirely in safe Rust can trigger undefined behavior. The research used Hyenas, FORGE’s frontier research version of codename MDASH, an AI-powered vulnerability-scanning system. The findings reveal three recurring patterns of misplaced trust in unsafe code: trusting code not to panic, trusting user-provided implementations to be correct, and trusting the underlying system.

Rust’s safety guarantees are precisely what make these findings interesting. Its rich type system and ownership model rule out whole classes of memory-safety issues, but much of the standard library relies on unsafe code underneath its safe APIs. When that code breaks its safety contract, even safe Rust can encounter behavior the language is designed to prevent.

Rust’s memory-safety guarantees are increasingly important as the language becomes part of software that billions of people rely on every day. Billions of people are estimated to interact with Rust-based software or operating systems daily, often without knowing it. Microsoft made Rust a Tier-1 internal language alongside C++, C#, and TypeScript, GitHub rewrote the Copilot agent runtime in Rust , and Bun , Android , the Linux kernel , and Cloudflare are moving code to it as well. Much of this software relies on Rust’s foundational libraries, core and std , and the safety guarantees of the APIs they provide. Bugs in those libraries can have consequences well beyond the code where they originate.

Unsafe Rust has been a long-running interest for us. Our team includes the people behind Rudra , a static analyzer that looked for memory-safety bugs across the Rust ecosystem in 2021. We also write many of our own tools in Rust, so its safety is more than a research topic for us. This year, we took a closer look at the standard library to see what kinds of mistakes still show up in its unsafe code today.

In this post, we share some of the bugs we reported to the Rust issue tracker. We use them to discuss what Rust does and doesn’t guarantee, why writing correct unsafe Rust is so difficult, and why Rust’s safety model still matters even though its memory safety isn’t perfect.

How we found and validated the bugs

At Microsoft FORGE Lab , we study vulnerabilities in complex software, including the Rust standard library. Our team combines years of experience in vulnerability research with AI-assisted tools that help us investigate code and find bugs that are difficult to uncover through traditional analysis alone.

Some of the bugs in this post were found with help from Hyenas, our research version of codename MDASH . Our researchers investigated the underlying code, reproduced the bugs, assessed their potential security impact, and worked with Rust maintainers to report and fix them.

This post focuses on soundness bugs in the standard library’s unsafe code. Bugs in the compiler itself, such as miscompilations and holes in the type system, are a different topic that we don’t cover here.

Patterns of Rust’s Safety Bugs

At the lowest level, Rust uses unsafe blocks to work with raw pointers and interact directly with the operating system. Much of the standard library, including Vec and String , is built from small unsafe pieces wrapped in safe APIs. Inside an unsafe block, the programmer takes responsibility for the guarantees the compiler can’t check, and that responsibility extends to the safe API built around it. That API must be sound : no matter how safe code uses it, it must be impossible to trigger undefined behavior.

Upholding that promise is harder than it looks. Consider a function that returns the byte at idx from any type that can be viewed as a byte slice, skipping the redundant bounds check after doing its own: 

pub fn get<S: AsRef<[u8]>>(s: &S, idx: usize) -> Option<u8> {
    if idx < s.as_ref().len() {
        // SAFETY: we just checked that `idx` is in bounds.
        Some(unsafe { *s.as_ref().get_unchecked(idx) })
    } else {
        None
    }
}

The hard part of unsafe Rust is knowing what you can trust. The function above looks correct, but it assumes that two calls to as_ref return the same slice. Because S is chosen by the caller, a safe AsRef implementation can return a long slice the first time and an empty one the second, and get reads out of bounds. Unsafe code must be careful with every call it makes, and the bugs we found fall into three patterns of misplaced trust: trusting code not to panic, trusting user-provided implementations to be correct, and trusting the underlying system.

Pattern 1: Trusting code not to panic

Unsafe code often breaks an invariant for a moment and restores it afterward; for example, it may allocate an uninitialized buffer and fill it directly, avoiding redundant writes to zero the memory first. That’s fine as long as the function runs to the end. But many operations in Rust can panic, from out-of-bounds indexing to calls into user-provided code, and by default a panic unwinds: it leaves the function early while still running destructors. Unwinding inside that window becomes an invisible exit that exposes the broken invariant to code that trusts it. Bugs of this kind are called panic safety bugs.

Flow diagram: a function breaks an invariant, calls code that may panic, and restores the invariant before returning. If the call panics, unwinding skips the restore step and runs a destructor on the broken state, causing undefined behavior.

MapWindows::clone (#156501)

We identified a panic safety issue in MapWindows::clone . Iterator::map_windows , a nightly API, yields overlapping windows of N items. It keeps the current window in a Buffer whose destructor drops the N items starting at start . In Rust 1.97.0, library/core/src/iter/adapters/map_windows.rs defines it as: 

37struct Buffer<T, const N: usize> {
38    // Invariant: `self.buffer[self.start..self.start + N]` is initialized,
39    // with all other elements being uninitialized. This also
40    // implies that `self.start <= N`.
41    buffer: [[MaybeUninit<T>; N]; 2],
42    start: usize,
43}

Buffer::clone , in the same file, built the new buffer first and filled it afterward: 

195impl<T: Clone, const N: usize> Clone for Buffer<T, N> {
196    fn clone(&self) -> Self {
197        let mut buffer = Buffer {
198            buffer: [[const { MaybeUninit::uninit() }; N], [const { MaybeUninit::uninit() }; N]],
199            start: self.start,
200        };
201        buffer.as_uninit_array_mut().write(self.as_array_ref().clone());
202        buffer
203    }
204}

After line 197, buffer breaks its own invariant: its slots are uninitialized, but its destructor is already armed. The clone() call on line 201 runs the user’s T::clone before the slots are written. If that call panics, unwinding drops buffer and runs drop_in_place on N uninitialized values. Our proof of concept uses only safe code: an element type whose clone always panics, which causes a crash when the destructor accesses uninitialized memory. The fix holds the new buffer in ManuallyDrop until it is fully written, so unwinding leaks the half-built buffer instead of dropping it.

The general lesson is to treat every call to code you don’t control, such as clone , drop , comparisons, closures, and iterator methods, as a possible early exit. Either finish the work that may panic before breaking an invariant, or make the broken state safe to unwind through: hold it in ManuallyDrop , or use a guard whose destructor restores the invariant, like Vec ’s internal SetLenOnDrop . The Rustonomicon covers this under exception safety .

Allocators must not unwind

The recently stabilized Allocator API shows how hard panic safety is to get right. With std , an allocation failure aborts the process by default instead of unwinding, so much of the standard library’s unsafe code assumes allocation never unwinds. Custom allocators can break that assumption. While the API was being stabilized, we reported one place in BTreeMap::insert that becomes unsound when an allocator unwinds, and others reported more ( #159334 , #159368 , #159370 ). Fixing them one by one would mean auditing everything that allocates, so the stabilization , shipping in Rust 1.100 on November 12, instead requires implementors never to unwind from the trait’s methods or from drop . The proposal notes that “unwinding out of many allocation-related methods was found to be a pervasive source of unsoundness.”

Pattern 2: Trusting user-provided implementations to be correct

Unsafe code often calls into code its caller provides: a comparator, a trait implementation, a closure. That code is safe, but safe doesn’t mean correct, and it can return inconsistent or plainly wrong answers. The question is who is responsible when it does. In C++, it’s the caller. std::sort requires its comparator to be a strict weak ordering, and breaking that rule is undefined behavior. With libstdc++, sorting equal elements with <= reads past the end of the vector: 

std::vector<int> v(100, 42);
// Bug: `<=` is not a strict weak ordering, since cmp(a, a) is true.
std::sort(v.begin(), v.end(), [](int a, int b) { return a <= b; });
// AddressSanitizer: heap-buffer-overflow in std::__introsort_loop

The same comparator passed to Rust’s sort_by is only a logic error. The sort may panic or leave the slice in an unspecified order, but it never causes undefined behavior. The responsibility sits with the unsafe code. The comparator is safe code supplied by the caller, so the unsafe code inside the sort must stay sound no matter what it returns. The same goes for every safe trait a user can implement: comparisons can be inconsistent, an ExactSizeIterator can report a length that doesn’t match the items it yields, and Borrow can return a different value on each call.

str::replace with a custom Pattern (#156491)

Another of our bug reports shows how easy this trust is to miss: str::replace with a custom Pattern can create a non-UTF-8 String . String search APIs accept any type that implements the nightly Pattern trait, and a pattern can describe itself through as_utf8_pattern . str::replace uses that description to take a fast path when replacing one ASCII byte with another. In Rust 1.96.0, the fast path in library/alloc/src/str.rs looked like this: 

268pub fn replace<P: Pattern>(&self, from: P, to: &str) -> String {
269    // Fast path for replacing a single ASCII character with another.
270    if let Some(from_byte) = match from.as_utf8_pattern() {
271        Some(Utf8Pattern::StringPattern([from_byte])) => Some(*from_byte),
272        Some(Utf8Pattern::CharPattern(c)) => c.as_ascii().map(|ascii_char| ascii_char.to_u8()),
273        _ => None,
274    } {
275        if let [to_byte] = to.as_bytes() {
276            return unsafe { replace_ascii(self.as_bytes(), from_byte, *to_byte) };
277        }
278    }

replace_ascii , in the same file, then rewrites the bytes: 

708unsafe fn replace_ascii(utf8_bytes: &[u8], from: u8, to: u8) -> String {
709    let result: Vec<u8> = utf8_bytes.iter().map(|b| if *b == from { to } else { *b }).collect();
710    // SAFETY: We replaced ascii with ascii on valid utf8 strings.
711    unsafe { String::from_utf8_unchecked(result) }
712}

The CharPattern branch on line 272 checks that the character is ASCII, but the StringPattern branch on line 271 assumes a one-byte string pattern must be ASCII. That holds for &str patterns, but StringPattern stored &[u8] , and as_utf8_pattern is a safe method any Pattern can implement. In our proof of concept, a custom pattern reports the single byte 0x80 , which only appears inside multibyte UTF-8 sequences: 

impl Pattern for NonAsciiBytePattern {
    // ...
    fn as_utf8_pattern(&self) -> Option<Utf8Pattern<'_>> {
        static NEEDLE: [u8; 1] = [0x80];
        Some(Utf8Pattern::StringPattern(&NEEDLE))
    }
}

// "\u{d000}" is [ed, 80, 80]; the result is [ed, 3f, 3f], which is not UTF-8.
let corrupted = "\u{d000}".replace(NonAsciiBytePattern, "?");

str::replace rewrites the continuation bytes and returns a String that isn’t valid UTF-8, and later string operations that rely on UTF-8 reach undefined behavior. The fix changed StringPattern to hold &str instead of &[u8] , so the type itself now guarantees UTF-8.

When unsafe code depends on a property of a user-provided implementation, don’t take it on faith. Call the implementation once and keep the result, validate what it returns, or encode the property in a type that safe code can’t forge, as this fix did. If none of those work, make the trait unsafe so implementors explicitly promise to uphold it.

More examples

join shows how easy it is to fix this kind of bug only partway. In 2020, we reported that it trusted Borrow::borrow to return the same string on each call ( CVE-2020-36323 ), and the fix handled strings that shrink between calls. In April 2026, the same function needed another fix : join borrows the first element twice, and if it grows on the second call, the remaining-length calculation underflows into a heap overflow. The earlier fix had never covered that path.

Others reported similar problems in the Pattern API this year. A safe Pattern can hand back a valid searcher built for a different string, and consumers such as strip_prefix_of apply its ranges to the original string unchecked, reading out of bounds ( #158265 ). The same problem turned up in split_once ( #165076 ) after a report that the Searcher contract doesn’t spell out what str::split relies on ( #164904 ). Both bugs are still open.

Pattern 3: Trusting the underlying system

The first two patterns stay inside Rust code. The third sits at the boundary with the operating system, where unsafe code trusts process-wide state such as signal stacks, memory mappings, and the environment, which other threads, C libraries, or the kernel can touch at any time. These bugs have been hard to find automatically, because a static analyzer would need to model all of that surrounding behavior. AI agents change the picture: they understand enough about the environment the code runs in to make this area practical to search. We started exploring it and found some interesting bugs.

process::exit and the main thread’s signal stack (#161018)

When a thread overflows its stack, Rust prints a clear message and aborts instead of crashing with a bare segmentation fault: 

thread 'main' (3307186) has overflowed its stack
fatal runtime error: stack overflow, aborting

This relies on a few pieces of process-wide state. Each thread’s stack ends in a guard page, an inaccessible region just past the stack’s limit: pthread reserves one for every spawned thread, and on Linux the kernel’s own stack guard plays that role for the main thread. Touching it raises SIGSEGV , and Rust registers a handler for that signal. The handler can’t run on the stack that just overflowed, so Rust also gives each thread an alternate signal stack, a small separate mapping with a guard page of its own, which the kernel switches to when it delivers the signal. The handler checks that the faulting address is inside the guard page, prints the message, and aborts.

Diagram: one column of memory. The main thread’s stack frames grow down until the next frame lands in the guard page below, which has no access. That access raises SIGSEGV, which invokes Rust’s registered signal handler. The handler runs on the alternate signal stack, a separate read/write mapping further down with its own guard page. In the bug, process::exit in a child thread unmaps that alternate stack while it is still registered.

We found that calling process::exit from a child thread tears down the main thread’s alternate stack while the main thread is still running. process::exit runs the runtime’s cleanup before calling libc’s exit , and in Rust 1.98.0 that cleanup ends in library/std/src/sys/pal/unix/stack_overflow.rs : 

196pub unsafe fn cleanup() {
197    if cfg!(panic = "immediate-abort") {
198        return;
199    }
200    // FIXME: I probably cause more bugs than I'm worth!
201    // see https://github.com/rust-lang/rust/issues/111272
202    unsafe { drop_handler(MAIN_ALTSTACK.load(Ordering::Relaxed)) };
203}

Line 202 passes MAIN_ALTSTACK , the main thread’s alternate stack, to drop_handler : 

297// SAFETY: we warned the caller this disables the alternate signal stack!
298unsafe { sigaltstack(&disabling_stack, ptr::null_mut()) };
299// SAFETY: We know from `get_stackp` that the alternate stack we installed is part of
300// a mapping that started one page earlier, so walk back a page and unmap from there.
301unsafe { munmap(data.sub(page_size), sigstack_size + page_size) };

Line 298 disables the alternate stack of the calling thread, but line 301 unmaps the main thread’s. The code assumes it runs on the main thread, which isn’t true when a child thread calls process::exit . The main thread keeps running until libc’s exit finishes, with its signal stack registration still pointing at unmapped memory. If it overflows its stack in that window, the kernel can’t deliver the signal, and our proof of concept dies with a plain segmentation fault instead of Rust’s message. The bug dates back to 2015 , and the fix stops cleaning up the main thread’s alternate stack altogether.

We also checked whether this could become a security issue. In theory, it could lead to code execution: if a writable mapping landed at the old alternate stack’s address, the kernel would deliver the main thread’s next signal onto it, and another thread could overwrite the handler’s frame, such as its return address, while it runs. In practice, the conditions are very tight. Everything has to happen in the brief window before libc’s exit finishes, the new mapping must have exactly the right size to reuse that address, and overwriting the frame takes a second race inside a short handler. For issue #161018, our testing found no reliable exploitation path under the conditions examined, and we assessed practical exploitation as unlikely. This assessment does not automatically apply to the other issues discussed. The issue has more details in its security impact analysis.

CommandExt::exec and the global environment (#156951)

Our other report involves the process environment. On Unix, CommandExt::exec replaces the current process with a new program. When the command has its own environment variables, exec points the process-global environ at a new array, calls execvp , and restores environ if execvp fails. In Rust 1.99.0, Command::exec takes the environment lock in library/std/src/sys/process/unix/unix.rs : 

242let _lock = sys::env::env_read_lock();
243
244let Err(e) = self.do_exec(theirs, envp.as_ref());

Command::do_exec , in the same file, then swaps the environment: 

409    _reset = Some(Reset(*sys::env::environ()));
410    *sys::env::environ() = envp.as_ptr();
411}
412
413libc::execvp(self.get_program_cstr().as_ptr(), self.get_argv().as_ptr());
414Err(io::Error::last_os_error())

Line 242 takes only the read side of the environment lock, yet line 410 writes the process-global environ ; line 409 saves the old value so it can be restored if execvp on line 413 fails. Writing environ under a read lock lets other threads in. A thread calling env::var takes the same read lock and can see variables meant only for the new program, and two failed exec calls racing each other can leave environ pointing at a freed array that a later env::vars_os() reads. Both proofs of concept use only safe Rust. A 2018 fix held an exclusive lock here, but when the environment lock became a read-write lock in 2021, exec kept the read side. A fix that avoids touching environ by calling execve directly is in review .

The environment has caused trouble before. After a discussion that began in 2015 , the 2024 edition marked env::set_var as unsafe , because C functions on most Unix platforms read the environment without going through Rust’s lock.

process::exit and thread-local destructors (#164243)

Getting this boundary right is hard, and more problems are still open. While exploring this area, we independently ran into a double free in safe code that process::exit can cause through thread-local destructors. It was reported by someone else ( #164243 ), but it’s worth mentioning here. libc’s exit first runs the calling thread’s thread-local destructors, as C++ requires, and Rust registers its destructors the same way. If a destructor calls process::exit while a thread local is being replaced, libc drops that thread local a second time. A proposed fix switches process::exit to POSIX _exit , which ends the process without running these handlers.

Conclusion

Every unsafe block rests on assumptions about the code around it. The bugs in this post came from three kinds of misplaced trust:

  • that code won’t panic at the wrong moment,
  • that a caller-provided implementation behaves correctly, and
  • that the process-wide state Rust shares with the operating system and the C library stays the way the code expects.

Familiar patterns are still difficult (Patterns 1 and 2)

The first two patterns are well studied. Rudra looked for both in 2021, and the standard library was already fixing panic safety bugs in 2015 ( CVE-2015-20001 ). They remain challenging to avoid because any call inside unsafe code might unwind or run code the caller supplied.

What we saw this year was mixed. On the positive side, the nightly process is working. Many reports were caught while the affected APIs were still unstable, and several were fixed by changing the design before stabilization. StringPattern now holds &str instead of &[u8] , and Allocator was stabilized with a rule that implementors must not unwind. At the same time, bugs in these patterns still reach stable releases, and their fixes aren’t always complete. join was fixed in 2020 and needed another fix in 2026 for a path the first fix had missed.

System boundary bugs are now within reach (Pattern 3)

The third pattern is different. Its bugs live where Rust meets the layers below it: the kernel, through system calls such as sigaltstack and munmap , and the C library, through process-wide state such as environ and the cleanup that libc’s exit runs. Getting them right takes knowledge that lives outside Rust’s type system, which has made these bugs difficult to find with traditional static analysis. That may also be why they last so long. The process::exit signal stack bug was in the standard library for nearly 11 years, and exec has written environ under a read lock since 2021. Unlike our reports in the first two patterns, both affect stable Rust.

Language models already know a great deal about how these interfaces behave, so agentic scanners can check unsafe code against the system it runs on, not just the language. We think this boundary is one of the most promising places for agentic security research, in Rust and beyond.

Rust’s high bar is hard to meet but worth keeping

Rust holds its safe APIs to a stricter standard than C and C++. Safe code must never be able to cause undefined behavior, no matter how it uses an API. In C++, a comparator that breaks std::sort ’s ordering requirement causes undefined behavior, while Rust’s sort must stay memory-safe with any Ord implementation. POSIX doesn’t guarantee that setenv is safe to call while another thread reads the environment. That makes memory safety bugs in Rust hard to compare one-to-one with bugs in other languages.

For the same reason, a soundness bug in the standard library isn’t automatically a vulnerability in the programs that use it. Each bug in this post needs an unusual setup to trigger, such as a panic at exactly the wrong moment, a deliberately misbehaving implementation, or calling process::exit from a child thread. It becomes a serious vulnerability only if a real program reaches the API in that way.

Rust’s safety standard is strict and difficult to meet, but it’s also useful. It gives an unambiguous answer to what counts as a soundness bug, so problems can be fixed and prevented once in the library, instead of in every program that uses it. Rust’s safety model strikes the right balance between control, safety, and performance for systems programming, which is why so many projects choose it.

Beyond the lab

At Microsoft FORGE Lab, we’re exploring how technology such as codename MDASH can help researchers find bugs like the ones in this post at greater scale. Rust’s standard library is one of several foundational open source projects where we’re applying this approach.

This research also extends beyond the lab. It helps inform the development of codename MDASH, which brings agentic vulnerability discovery into Microsoft Defender. These findings can also serve as inputs to Microsoft Perception, our new multi-agent security system, where specialized agents work together across broader security workflows. For example, the Web App Pen Test Agent can use codename MDASH findings to help prioritize testing, validate exploitability against live applications, and produce actionable vulnerabilities that downstream agents can use to prioritize and support remediation. This connects AI-powered code analysis with real-world security validation and response, helping security teams move from identifying potential vulnerabilities to understanding and addressing actual risk.

Our goal isn’t to simply find more bugs, it’s to identify meaningful issues, turn those findings into actionable research, and improve the safety of foundational software that developers and organizations depend on.

Hackers exploit trusted AWS access to breach multiple cloud environments

Bleeping Computer
www.bleepingcomputer.com
2026-11-10 14:31:11
A threat actor used compromised identity and access management (IAM) credentials for a Qubole big data platform's AWS account to access and exfiltrate data from multiple customers' AWS environments. [...]...
Original Article

Hackers exploit trusted AWS access to breach multiple cloud environments

A threat actor used compromised identity and access management (IAM) credentials for a Qubole big data platform's AWS account to access and exfiltrate data from multiple customers' AWS environments.

The campaign ran between October 14 and 26, and affected tens of companies whose AWS environments had IAM roles configured to trust an AWS account associated with Qubole.

Qubole is an enterprise cloud data processing and analytics platform that helps companies manage large datasets and run machine learning workloads. It also offers AWS integration to allow computing resource management.

image

Companies can grant third-party providers such as Qubole access to their AWS resources by creating cross-account IAM roles. Trust policies determine which external AWS accounts can take these roles, and permissions are set to define the resources and actions allowed.

Researchers at cloud security company Wiz explain that external providers use AWS’s STS AssumeRole API to obtain temporary credentials for accessing customers' resources in the cloud.

Wiz started to investigate the attack after data security and governance company Sentra shared information about suspicious activity observed in some of its customers' environments. The investigation also included cybersecurity company Mandiant.

The researchers found that the attacker had compromised two Qubole IAM users and assumed otherwise unused roles in multiple customers’ AWS accounts that had previously been configured to trust Qubole’s account, granting them access within the role’s permissions.

Overview of the attack
Overview of the attack
Source: Sentra

Wiz says the attacker then surveyed cloud resources, retrieved secrets from AWS Secrets Manager and SSM Parameter Store, and read Lambda environment variables.

They then used the TruffleHog tool to validate discovered AWS keys, Microsoft Entra ID client secrets, and Okta client credentials.

Once they gained deeper access, they downloaded data from all accessible S3 buckets in the AWS environment, following an opportunistic approach rather than carefully targeting specific data.

“The sequence was consistent across environments: assume a role, call ListBuckets to see what the role could reach, call ListObjects and HeadObject to enumerate and inspect the contents, then call GetObject to download them,” Wiz explains .

The report does not specify the exact method used to compromise the Qubole accounts or the number of downstream victims. However, Sentra confirmed dozens of victims and millions of files stolen from one customer alone.

Sentra says the attacker moved quickly and collected secrets at a rate of 100 passwords and keys in seven minutes.

BleepingComputer could not find a public announcement from Qubole about this incident. We have emailed the firm for more information about the attack and await their response.

Potentially impacted administrators are advised to review CloudTrail from October 1 onward for suspicious access from Qubole’s AWS account, investigate subsequent secret and S3 access, rotate exposed credentials, and revoke active role sessions.

It is also recommended to remove unused integrations and restrict remaining roles’ permissions, trusted identities, and permitted source networks.

article image

Uncover email threats your existing defenses may miss.

Adaptive Security's AI agents analyze email intent, context, and behavior to uncover phishing, business email compromise, and invoice fraud.

See what's getting through with a 14-day read-only scan of Microsoft 365 or Google Workspace, with no MX changes.

Start your free email security scan.

What objective is reasoning solving?

Hacker News
alexwang.ai
2026-11-10 14:25:14
Comments...
Original Article

Reasoning as pathfinding in token space.

Reasoning as pathfinding. Each sample $z$ is an attempt to find a path from the starting context $x$ to a correct answer $y(z)$ in $\Scal_x$.

There’s an intuitive but simplified picture of reasoning: let a model think for longer, and it’ll be more likely to be correct. This aligns well with our human intuition: spend more time and effort on thinking and it’s more likely that we’ll arrive at a correct answer.

But this picture doesn’t seem to explain everything. During RL training, models learn to write longer chains of thought, and they get more accurate as they do. Yet if you take a trained model and force any one chain to run longer, it helps for a while, then stops helping. 1 Sometimes the answer even gets worse , as if it’s overthinking. 2 If a chain of thought were truly converging toward some optimum, more steps shouldn’t make it worse. So is it really the length of each chain that helps at inference time? Or is it something more subtle?

This post is my attempt to clarify this confusion (mostly for myself) by looking at reasoning as pathfinding through token space. We’ll see that RL maximizes the probability of finding a path from $x$ to $\Scal_x$, but individual paths are not guaranteed to converge to the correct answer. As a bonus, this perspective clarifies some odd observations about reasoning models, like unfaithful chains of thought and reward hacking.

Reasoning as pathfinding #

Ask a reasoning model the same math problem ten times and you’ll get ten different chains of thought. Rather than thinking of reasoning as one mysterious process heading toward an answer, let’s think of it as pathfinding in token space. There are many paths from the problem to a correct answer, and the model traverses one of them with each sample.

Consider the problem: “what’s $1 + 2 + 3 + \cdots + 10$”? One solution is to add the numbers one at a time: 1, 3, 6, 10, and so on up to 55. Another way is to pair them from the outside in: $1 + 10$, $2 + 9$, $3 + 8$, $4 + 7$ and $5 + 6$ each make 11, and five pairs of 11 make 55. Both of these paths land on the correct answer, 55.

We can think about reasoning as following this general pattern. We are given a starting point, the prompt, which we’ll call $x$. We want to find a path $z$ that starts from $x$ and ends at a correct answer $y$. To tell whether a path lands in the right place, we assume we have a verifier $r(x, y)$ that returns 1 if $y$ is correct and 0 if it isn’t.

So given a starting point $x$, we want to find a path of tokens $z$ that lands in the set

$$\Scal_x = \{y : r(x, y) = 1\}.$$

The figure at the top of this post sketches this picture. Each gray line is a sampled path: it starts from the prompt on the left, meanders in token space by sampling $z$, with some of these paths landing in $\Scal_x$.

Since many paths land in $\Scal_x$, the success probability adds up over all of them. Let $\pi(z \mid x)$ be the probability that the model generates the path $z$ given the prompt $x$, and $y(z)$ for the final answer at the end of $z$. The probability of success is the probability of generating each path, times the probability that path lands in $\Scal_x$, summed over every path:

$$p_x = \prob{\text{a path lands in } \Scal_x \mid x} = \sum_{z} \underbrace{\pi(z \mid x)}_{\text{samples path } z}\; \underbrace{\prob{y(z) \in \Scal_x \mid z}}_{\text{path } z \text{ lands in }\Scal_x}.$$

The second factor is just 1 if the path lands in $\Scal_x$ and 0 if it doesn’t, so we sum only the probability of paths that land in $\Scal_x$:

$$p_x = \sum_{z} \pi(z \mid x)\, \ind{y(z) \in \Scal_x} = \sum_{z \,:\, y(z) \in \Scal_x} \pi(z \mid x).$$

We’ll call $p_x$ the success probability . Maximizing this probability means our model will be more likely to sample a path that lands in $\Scal_x$.

Note that there are two ways of increasing this probability. Either the model can sample multiple paths to the same answer, each with a small probability, or the model can sample a single path to the answer with a very high probability. The success probability doesn’t care which one we get, but in practice we might want to prioritize specific paths or ensure diversity in the samples 3 .

How do we boost our success probability? #

Best-of-$k$ sampling #

The simplest way to pathfind is to have the model $\pi$ keep sampling paths $z$ until one lands in $\Scal_x$.

Since we assumed we had a verifier, we can do best-of-$k$ sampling, which samples $k$ paths and looks for a success. Each path misses with probability $1 - p_x$, so all $k$ miss with probability $(1-p_x)^k$, and the success probability rises from $p_x$ to

$$\prob{\text{at least one of } k \text{ paths lands in } \Scal_x \mid x} = 1 - \underbrace{(1-p_x)^k}_{\text{all } k \text{ paths miss}}.$$

This is a guaranteed axis of compute-scaling. As long as $p_x > 0$, the success probability increases monotonically as we sample more paths, so spending more compute on more samples always helps, as seen early on by Brown et al. 2024 . However, the scaling here is over the number of samples rather than the length of the paths (thinking longer).

Train the model to generate better samples #

So far the model was fixed, so $p_x$ was fixed too. Can we change the model to increase $p_x$ itself?

Here’s a simple way to do this. Collect many prompts whose answers we can check. For each one, sample some paths from the model. We keep the paths that land in $\Scal_x$, and train the model on the ones we kept. Then repeat. Each round, we train the model to put more weight on the successful paths that it sampled. This loop is called rejection-sampling fine-tuning, and STaR was an early version of it for reasoning.

RL with a verifiable reward, which is how today’s reasoning models are trained, turns out to do almost the same thing. Let $\pi_\theta$ be the model with weights $\theta$. Then since $r(x, y(z)) = 1$ exactly when $y(z) \in \Scal_x$:

$$ \begin{aligned} p_x &= \sum_{z \,:\, y(z) \in \Scal_x} \pi_\theta(z \mid x) \\ &= \sum_{z} \pi_\theta(z \mid x)\, \ind{y(z) \in \Scal_x} \\ &= \sum_{z} \pi_\theta(z \mid x)\, r(x, y(z)) \\ &= \ev[z \sim \pi_\theta(\cdot \mid x)]{r(x, y(z))}, \end{aligned} $$

meaning the expected binary reward is exactly the success probability $p_x$.

Computing the gradient of the success probability via the log-derivative trick, we arrive at

$$\grad_\theta\, p_x = \ev[z \sim \pi_\theta(\cdot \mid x)]{r(x, y(z))\, \grad_\theta \log \pi_\theta(z \mid x)},$$

which is exactly the policy gradient, also called the REINFORCE estimator. Now estimate this gradient with $N$ sampled paths $z_1, \dots, z_N$. The paths that failed have $r = 0$ and disappear, while the paths that land in $\Scal_x$ have $r = 1$. If $M$ of the $N$ paths succeed, the estimate is

$$\grad_\theta\, p_x \approx \frac{1}{N} \sum_{i \,:\, \text{landed}} \grad_\theta \log \pi_\theta(z_i \mid x) = \underbrace{\frac{M}{N}}_{\text{success rate}} \cdot \underbrace{\frac{1}{M} \sum_{i \,:\, \text{landed}} \grad_\theta \log \pi_\theta(z_i \mid x)}_{\text{log likelihood of the successful paths}}.$$

This gradient involves two terms: the empirical success rate $M/N$ and the average log likelihood of the successful paths.

In other words, a step of REINFORCE with a binary reward is a step of rejection-sampling fine-tuning on the model’s own sampled paths, scaled by the current success rate $M/N$.

This also explains the first observation from the intro, that chains of thought get longer during RL training. Each step pulls the model toward the paths that landed, so if the paths that succeeded tended to be longer than the ones that failed (e.g. because they include backtracking behavior, gather more feedback from the environment, or just dumb luck), the model will learn to write longer paths.

Amortization and generalization #

During RL training, we spend a lot of compute to search for good paths and then we train the model to generate those paths directly. Once trained, the model can produce the answer without spending all this extra compute on sampling multiple paths. This is called amortizing the search: we pay for it once during training, so we don’t have to pay for it every time we ask the model a question. 4 Since we train a single model on many prompts, the model can potentially generalize to new prompts it has never seen.

The figure below shows this for four prompts, each with its own $\Scal_x$, and switches between the model before and after training. During training, we sample paths from every prompt, keep the ones that succeed, and SFT on them. The percentages show the empirical rate of success given each prompt. The hollow prompt is new and not seen before by the model, but the model generalizes to this new prompt after training. As the new prompt gets further from the training distribution, its accuracy drops (try dragging it!).

Try dragging the new prompt.

Revisiting some observations about reasoning #

Once we see a reasoning model as a distribution trained to land in $\Scal_x$ given any $x$, a few odd facts about these models become clear.

Chains of thought are not guaranteed to be faithful #

Our verifier above only checks whether the answer is correct. The reward is 1 if $y(z) \in \Scal_x$ and 0 otherwise, so the intermediate tokens $z$ are just a way for the model to get to the answer. Nothing requires those tokens to be true, or to explain the answer that follows, though of course these are often correlated due to the model’s pretraining.

If we want meaningful chains of thought, we need to adjust the rewards or the training objective.

Reward hacking comes from both the verifier and the sampler #

We also assumed the verifier is never wrong, that $r(x, y)=1$ if and only if $y$ is actually the correct answer to $x$. But in practice the verifier can be imperfect. Then $\Scal_x$, the set of answers the verifier accepts, isn’t the same as the set of correct answers: it can include wrong answers and leave out correct ones. This misspecification opens up regions of $\Scal_x$ that the model might learn to land in even though it’s not what we intended.

Thus reward-hacking comes from an imperfect verifier, which fails to capture what we truly want, as well as an imperfect sampling procedure which fails to stay away from these shortcut regions.

In the figure below, the dashed circle is the set of correct answers and the red ellipse is $\Scal_x$. The ellipse stretches back toward the prompt, so its wrong answers are the easiest to reach, and after training most paths land there.

This visualization also shows why scaling up RL (generating more samples and longer samples) makes reward hacking more likely. The more extensively we “fuzz” the verifier, the more likely we’ll find a path that lands in the misspecified region of $\Scal_x$. Once the model finds this shortcut, training pushes the model towards similar behavior.

So what objective is reasoning solving? #

Reasoning isn’t actually solving any objective at all. A path is not guaranteed to converge to the correct answer. It’s only in aggregate, over the distribution of paths, do we get a high probability of success.

RL training directly raises the success probability $p_x$, by spending a lot of compute on searching for successful paths and then training the model to reproduce them. The gains we credit to “thinking longer” come from the search we paid for during training, rather than at inference. Longer chains of thoughts tend to correlate with success during training, which then gets trained into the model. The cost of the sampling is amortized into the weights, so at inference time the model is likely to succeed with a single sample, but any individual sample is not guaranteed to succeed.

Saltline: First-person shooter built by Fable 5.2

Hacker News
claude.ai
2026-11-10 14:14:38
Comments...
Original Article

Content is user-generated and unverified.

Microsoft November 2026 Patch Tuesday fixes 1,235 flaws, Outlook zero-day

Bleeping Computer
www.bleepingcomputer.com
2026-11-10 14:07:36
Today is Microsoft's November 2026 Patch Tuesday, with security updates addressing a record-breaking 1,235 flaws, including one actively exploited Microsoft Outlook zero-day vulnerability. [...]...
Original Article

Today is Microsoft's November 2026 Patch Tuesday, with security updates addressing a record-breaking 1,235 flaws, including one actively exploited Microsoft Outlook zero-day vulnerability.

This Patch Tuesday addresses 66 "Critical" vulnerabilities, 48 of which are Remote Code Execution (RCE), 15 are Elevation of Privilege (EoP), and three are Use-After-Free in Microsoft Edge.

Of the 1,235 vulnerabilities, approximately 639 are categorized under Windows or Microsoft Windows products/components.

When BleepingComputer reports on Patch Tuesday security updates, we only count vulnerabilities released by Microsoft on Patch Tuesday itself.

Therefore, today's total excludes 108 flaws fixed earlier this month, including one Entra Device Registration, 82 Mariner, and 25 Microsoft Edge flaws.

November's Patch Tuesday comes after a record-breaking 1,411 flaws in the October updates as Microsoft continues to use AI to find and patch vulnerabilities.

This month's Patch Tuesday fixes one zero-day vulnerability in Microsoft Outlook that was exploited in attacks.

Microsoft classifies a zero-day flaw as publicly disclosed or actively exploited when no official fix is available.

The actively exploited zero-day vulnerability addressed in the November 2026 Patch Tuesday updates is:

Microsoft patched a Microsoft Outlook Spoofing zero-day vulnerability that was actively exploited in attacks to steal NTLM account hashes.

"An unauthenticated attacker could send a specially crafted message file and convince a user to open it in an affected version of Microsoft Outlook," warns Microsoft.

"Opening the file could cause Outlook to connect to an attacker-controlled network location without displaying the usual external-content warning, potentially disclosing authentication information that could be used to impersonate the user. Exploitation requires network connectivity and user interaction."

This type of vulnerability is known as an NTLM credential disclosure flaw, where a malicious attachment, when opened, causes Windows to connect to an attacker-controlled network share.

When connecting, Windows may automatically attempt to authenticate to the remote server, exposing the user's NTLMv2 authentication hash, which can then be captured by the attacker and potentially cracked offline.

The recovered credentials could then be used to gain unauthorized access to corporate accounts.

Below is the complete list of resolved vulnerabilities in the November 2026 updates. Note, this report does include the flaws fixed earlier this month.

To access the full description of each vulnerability and the systems it affects, you can view the full report here .

Tag CVE ID CVE Title Severity
.NET CVE-2026-118747 .NET Denial of Service Vulnerability Important
.NET CVE-2026-118746 .NET Security Feature Bypass Vulnerability Important
.NET CVE-2026-120796 .NET Denial of Service Vulnerability Important
.NET CVE-2026-114155 .NET Elevation of Privilege Vulnerability Important
.NET CVE-2026-105544 .NET Elevation of Privilege Vulnerability Important
.NET CVE-2026-109475 .NET Denial of Service Vulnerability Important
Active Directory Domain Services CVE-2026-105568 Windows Active Directory Domain Services Denial of Service Vulnerability Important
Active Directory Domain Services CVE-2026-118146 Windows Active Directory Domain Services Remote Code Execution Vulnerability Critical
Active Directory Domain Services CVE-2026-118735 Active Directory Domain Services Elevation of Privilege Vulnerability Important
Active Directory Domain Services CVE-2026-118148 Active Directory Domain Services Elevation of Privilege Vulnerability Critical
ActiveSyncProvider CVE-2026-119889 ActiveSyncProvider Information Disclosure Vulnerability Important
AMD Zen CVE-2026-84004 AMD Zen Information Disclosure Vulnerability Important
AMD Zen CVE-2026-84005 AMD Zen Information Disclosure Vulnerability Important
ASP.NET Core CVE-2026-109476 ASP.NET Core Information Disclosure Vulnerability Important
ASP.NET Core CVE-2026-109478 ASP.NET Core Denial of Service Vulnerability Important
ASP.NET Core CVE-2026-118741 ASP.NET Core Elevation of Privilege Vulnerability Important
ASP.NET Core CVE-2026-118750 ASP.NET Core Denial of Service Vulnerability Important
ASP.NET Core CVE-2026-118749 ASP.NET Core Denial of Service Vulnerability Important
ASP.NET Core CVE-2026-118748 ASP.NET Core Denial of Service Vulnerability Important
ASP.NET Core CVE-2026-109481 ASP.NET Core Elevation of Privilege Vulnerability Important
ASP.NET Core CVE-2026-114156 ASP.NET Core Security Feature Bypass Vulnerability Important
ASP.NET Core CVE-2026-114150 ASP.NET Core Information Disclosure Vulnerability Important
ASP.NET Core CVE-2026-114154 ASP.NET Core Denial of Service Vulnerability Important
ASP.NET Core CVE-2026-114149 ASP.NET Core Denial of Service Vulnerability Important
ASP.NET Core CVE-2026-114146 ASP.NET Core Elevation of Privilege Vulnerability Important
ASP.NET Core CVE-2026-114147 ASP.NET Core Denial of Service Vulnerability Important
ASP.NET Core CVE-2026-114157 ASP.NET Core Security Feature Bypass Vulnerability Important
Aspire CVE-2026-118740 Aspire Security Feature Bypass Vulnerability Important
Aspire CVE-2026-120006 Aspire Elevation of Privilege Vulnerability Important
Aspire CVE-2026-120792 Aspire Information Disclosure Vulnerability Important
Aspire CVE-2026-120778 Aspire Elevation of Privilege Vulnerability Important
Azure CLI CVE-2026-109457 Azure CLI Remote Code Execution Vulnerability Important
Azure Confidential Clean Rooms CVE-2026-121668 Azure Confidential Clean Rooms Tampering Vulnerability Important
Azure CycleCloud CVE-2026-114161 Azure CycleCloud Elevation of Privilege Vulnerability Important
Azure CycleCloud CVE-2026-113822 Azure CycleCloud Elevation of Privilege Vulnerability Important
Azure CycleCloud CVE-2026-102224 Azure CycleCloud Elevation of Privilege Vulnerability Important
Azure CycleCloud CVE-2026-113823 Azure CycleCloud Information Disclosure Vulnerability Important
Azure DevOps CVE-2026-109467 Azure DevOps Server Remote Code Execution Vulnerability Important
Azure DevOps Server CVE-2026-85923 Azure DevOps Server Elevation of Privilege Vulnerability Important
Azure DevOps Server CVE-2026-112745 Azure DevOps Server Information Disclosure Vulnerability Important
Azure DevOps Server CVE-2026-120783 Azure DevOps Server Elevation of Privilege Vulnerability Important
Azure File Sync CVE-2026-118288 Microsoft Azure File Sync Elevation of Privilege Vulnerability Important
Azure Firmware CVE-2026-109462 Azure Firmware Security Feature Bypass Vulnerability Important
Azure Front Door (AFD) CVE-2026-118742 Azure Front Door Elevation of Privilege Vulnerability Important
Azure Local CVE-2026-105734 Azure Local Elevation of Privilege Vulnerability Important
Azure Managed Grafana CVE-2026-114160 Azure Managed Grafana Elevation of Privilege Vulnerability Critical
Azure NFS mount helper (aznfs) CVE-2026-105494 Azure NFS mount helper (aznfs) Elevation of Privilege Vulnerability Important
Azure OpenAI CVE-2026-119990 Azure OpenAI Elevation of Privilege Vulnerability Critical
Azure Pipelines CVE-2026-119989 Azure Pipelines Remote Code Execution Vulnerability Important
Connected Devices Platform Service (Cdpsvc) CVE-2026-96007 Connected Devices Platform Service (Cdpsvc) Elevation of Privilege Vulnerability Important
Data Deduplication CVE-2026-119883 Data Deduplication Security Feature Bypass Vulnerability Important
Data Sharing Service Client CVE-2026-95963 Data Sharing Service Client Elevation of Privilege Vulnerability Important
Desktop Window Manager CVE-2026-96103 Desktop Window Manager Elevation of Privilege Vulnerability Important
Desktop Window Manager CVE-2026-105581 Desktop Window Manager Elevation of Privilege Vulnerability Important
Desktop Window Manager CVE-2026-96175 Desktop Window Manager Elevation of Privilege Vulnerability Important
Desktop Window Manager CVE-2026-96174 Desktop Window Manager Elevation of Privilege Vulnerability Important
Desktop Window Manager CVE-2026-113819 Desktop Window Manager Elevation of Privilege Vulnerability Important
Desktop Window Manager CVE-2026-96172 Desktop Window Manager Elevation of Privilege Vulnerability Important
Desktop Window Manager CVE-2026-113758 Windows Desktop Window Manager Elevation of Privilege Vulnerability Important
Desktop Window Manager CVE-2026-105528 Desktop Window Manager Elevation of Privilege Vulnerability Important
Desktop Window Manager CVE-2026-112988 Windows Desktop Window Manager Elevation of Privilege Vulnerability Important
Entra Device Registration CVE-2026-109469 Entra Device Registration Elevation of Privilege Vulnerability Critical
Github Copilot CVE-2026-83953 GitHub Copilot for Jetbrains Information Disclosure Vulnerability Important
Graphic Fonts CVE-2026-96084 Graphic Fonts Elevation of Privilege Vulnerability Important
Graphic Fonts CVE-2026-88211 Graphic Fonts Information Disclosure Vulnerability Important
Graphic Fonts CVE-2026-119969 Graphic Fonts Remote Code Execution Vulnerability Critical
HEIF Image Extensions CVE-2026-100204 HEIF Image Extensions Remote Code Execution Vulnerability Important
HID class driver CVE-2026-96059 HID class driver Information Disclosure Vulnerability Important
HID Parser Library CVE-2026-96974 HID Parser Library Elevation of Privilege Vulnerability Important
HID Parser Library CVE-2026-125135 HID Parser Library Elevation of Privilege Vulnerability Important
HID Parser Library CVE-2026-96982 HID Parser Library Elevation of Privilege Vulnerability Important
HID Parser Library CVE-2026-96979 HID Parser Library Elevation of Privilege Vulnerability Important
HID Parser Library CVE-2026-122173 HID Parser Library Elevation of Privilege Vulnerability Important
HID Parser Library CVE-2026-96010 HID Parser Library Elevation of Privilege Vulnerability Important
JDBC Driver for SQL Server CVE-2026-70003 JDBC Driver for SQL Server Security Feature Bypass Vulnerability Important
Kernel Transaction Manager CVE-2026-94517 Windows Kernel Transaction Manager Information Disclosure Vulnerability Important
Kernel Transaction Manager CVE-2026-122297 Windows Kernel Transaction Manager Information Disclosure Vulnerability Important
Kernel Transaction Manager CVE-2026-94522 Windows Kernel Transaction Manager Elevation of Privilege Vulnerability Important
Kernel Transaction Manager CVE-2026-119397 Windows Kernel Transaction Manager Elevation of Privilege Vulnerability Important
Mailslot File System CVE-2026-105537 Mailslot File System Information Disclosure Vulnerability Important
Mariner CVE-2026-120756 Heap Buffer Over-read via Malformed Message Size in HDF5's H5O__chunk_deserialize Low
Mariner CVE-2026-120755 Integer Underflow Leads to Out-of-Bounds Read via Truncated Chunk in HDF5 Szip Filter Moderate
Mariner CVE-2026-120754 Uninitialized Heap Memory Disclosure via Truncated Chunk in HDF5 Scale-Offset Filter Low
Mariner CVE-2026-120830 Libslirp: libslirp: out-of-bounds heap read in icmp_forward_error() leading to information disclosure Moderate
Mariner CVE-2026-120758 NULL Pointer Dereference in H5HL_unprotect via Corrupted File Moderate
Mariner CVE-2026-99281 tun: Require CAP_NET_ADMIN to attach to an ownerless device Important
Mariner CVE-2026-120689 Uncontrolled Recursion in HDF5 H5B__iterate_helper() via Crafted File Low
Mariner CVE-2026-120647 CGI versions before 5.00 for Perl allow Content-Disposition parameter injection via unescaped double quotes in the header attachment filename Moderate
Mariner CVE-2026-120645 CGI versions before 5.00 for Perl allow denial of service via submitted values used as a regex for optgroup selection in scrolling_list Moderate
Mariner CVE-2026-120644 CGI::Cookie versions before 5.00 for Perl allow cookie attribute injection via unvalidated path, domain and expires values Moderate
Mariner CVE-2026-120651 CGI versions before 5.00 for Perl allow an infinite loop on a short request body when $DISABLE_UPLOADS is set Moderate
Mariner CVE-2026-120650 CGI versions before 5.00 for Perl allow memory, CPU and disk exhaustion via missing or unenforced request size, parameter and upload limits Moderate
Mariner CVE-2026-120648 CGI versions before 5.00 for Perl allow HTML injection via text containing --> in comment Moderate
Mariner CVE-2026-99220 asymmetric_keys: reject trust keys without IDs Moderate
Mariner CVE-2026-99219 ftrace: Initialize modname and offset in print_rec() Moderate
Mariner CVE-2026-99218 coredump: hold RCU while releasing parked threads Moderate
Mariner CVE-2026-99223 keys: make keyring indexes independent of kernel addresses Low
Mariner CVE-2026-99222 keys: Protect the read method check against type removal Moderate
Mariner CVE-2026-99221 keys/trusted_keys: return immediately after TPM unseal failure Low
Mariner CVE-2026-97371 ntopng: Stack buffer overflow (write) in nDPI custom category detection allows remote code execution via crafted network packets Moderate
Mariner CVE-2026-123158 sshd in OpenSSH before 10.6p2 on Linux, when musl libc is used without PAM, lacks a workaround for a password authentication bypass (related to misinterpretation of whether a string is intended to be a password hash). For some configurations of accounts, any password between 256 and 1024 characters succeeds. An example of a platform using musl libc without PAM is Alpine Linux. Important
Mariner CVE-2026-121520 Malicious client could set xattr value outside of BuildKit state directory Moderate
Mariner CVE-2026-120831 Libslirp: libslirp: queue pointer corruption in if_output() leading to denial of service Moderate
Mariner CVE-2026-82413 ntopng: authenticated (non-admin) OS command injection via the vulnerability-scan `scan_ports` parameter (`nmap` argument reaches `popen`) Important
Mariner CVE-2026-124586 Tencent RapidJSON diyfp.h GetCachedPowerByIndex out-of-bounds Moderate
Mariner CVE-2026-124317 libexpat through 2.10.0 Out-of-Bounds Read via unknown_toUtf8 and unknown_toUtf16 Moderate
Mariner CVE-2026-120642 CGI versions before 5.00 for Perl return request-derived values untainted under taint mode Moderate
Mariner CVE-2026-112910 filelock: WindowsFileLock ignores mode: a 0o600 lock file and the ReadWriteLock database inherit the directory ACL Moderate
Mariner CVE-2026-100408 Git for Windows: git-credential-wincred Erase Path Heap Overflow Moderate
Mariner CVE-2026-100407 Git for Windows: git-credential-wincred OAuth Store Heap Overflow Moderate
Mariner CVE-2026-115710 Use of Cache Containing Sensitive Information in Elasticsearch Leading to Information Disclosure Moderate
Mariner CVE-2026-115298 Incorrect Authorization in Elasticsearch Leading to Information Disclosure Moderate
Mariner CVE-2026-114456 Missing origin validation for the externalbrowser authenticator callback in multiple Snowflake client drivers Moderate
Mariner CVE-2026-100082 xen-blkback: Avoid UAF when reading I/O statistics Moderate
Mariner CVE-2026-99283 netfilter: conntrack: tcp: use UNACK timeout for non-closing RST packets Low
Mariner CVE-2026-99284 net: skbuff: propagate shared-frag marker in skb_zerocopy() Moderate
Mariner CVE-2026-120757 Heap Buffer Over-read via Non-Terminated Link Data in H5L__extern_traverse Moderate
Mariner CVE-2026-100081 xen-netback: defer xenvif_mcast_addr_list_free() Moderate
Mariner CVE-2026-100080 xen-netback: Fix UAF when reading statistics data Moderate
Mariner CVE-2026-99282 net/sched: sch_teql: fix use-after-free on lower qdisc drop Moderate
Mariner CVE-2026-115715 Allocation of Resources Without Limits or Throttling in Elasticsearch Leading to Denial of Service Moderate
Mariner CVE-2026-120638 CGI versions before 5.00 for Perl allow open redirects via HTML entity decoding of the URL after application validation in redirect Moderate
Mariner CVE-2026-120636 CGI versions before 5.00 for Perl allow open redirects and script injection via URLs built from REQUEST_URI in url and start_form Moderate
Mariner CVE-2026-120635 CGI versions before 5.00 for Perl allow form fields to be smuggled past proxies and WAFs via multipart parsing that differs from the RFCs Moderate
Mariner CVE-2026-120641 CGI versions before 5.00 for Perl return upload filenames with any client-supplied path, including ../ and Windows paths Important
Mariner CVE-2026-120640 CGI versions before 5.00 for Perl allow the POSTDATA, PUTDATA, PATCHDATA and XForms:Model parameters to be set from the query string or form fields Important
Mariner CVE-2026-120639 CGI versions before 5.00 for Perl allow HTTP header injection via entity decoding after the newline check in header and unchecked values in multipart_start and do_push Moderate
Mariner CVE-2026-120633 CGI versions before 5.00 for Perl trust the client X-Forwarded-Host header in url, self_url, virtual_host and virtual_port Moderate
Mariner CVE-2026-120453 The Sleuth Kit through 4.15.0 Heap Out-of-Bounds Read via HFS+ decmpfs Header Moderate
Mariner CVE-2026-119776 frr: ospf6d fails to enforce all OSPFv3 packets use IPv6 link-local addresses Moderate
Mariner CVE-2026-119741 rsync < 3.5.2 Denial of Service via hash_search() Checksum Collisions Important
Mariner CVE-2026-120632 CGI versions before 5.00 for Perl allow CPU exhaustion via a backtracking regex on the XForms multipart/related Content-Type Moderate
Mariner CVE-2026-120457 libaec through 1.1.7 Out-of-Bounds Read via m_se_decode() Second Extension Decoder Moderate
Mariner CVE-2026-120454 The Sleuth Kit through 4.15.0 NULL Pointer Dereference via decmpfs LZVN Decompression Moderate
Mariner CVE-2026-99246 tipc: protect node reset trace dump with node lock Important
Mariner CVE-2026-99245 KEYS: Fix key_reject_and_link() race with keyring restriction Moderate
Mariner CVE-2026-99243 io-wq: order the exit bit against worker creation task work Moderate
Mariner CVE-2026-99251 Drivers: hv: Avoid infinite retry loop in init_vp_index() Moderate
Mariner CVE-2026-99249 pid_namespace: make zap_pid_ns_processes() freezable Low
Mariner CVE-2026-99247 tracing: Do not initialize tracefs work if tracing is disabled Moderate
Mariner CVE-2026-99236 tracing: Reject incomplete event filter expressions Moderate
Mariner CVE-2026-99229 io_uring/wait: don't spin on a stuck overflow list Moderate
Mariner CVE-2026-99226 keys: Avoid the owner account dereference in named keyring lookup Moderate
Mariner CVE-2026-99225 keys: Check the authorization payload in process keyring searches Moderate
Mariner CVE-2026-99235 tracing: Save the event file instead of the compatible histogram Moderate
Mariner CVE-2026-99234 tracing: Unregister field variable histograms when the command fails Low
Mariner CVE-2026-99233 tracing/histograms: Verify event_call identity when updating synth_event refcount Moderate
Mariner CVE-2026-99254 io_uring: don't flood a cancelling task with task_work Moderate
Mariner CVE-2026-99272 smb: client: validate the data area in SMB2_read() Moderate
Mariner CVE-2026-99271 ALSA: line6: Clear prev_fbuf on capture buffer release Moderate
Mariner CVE-2026-99270 tcp: Fix potential UAF in reqsk_timer_handler(). Important
Mariner CVE-2026-99275 smb: client: reject short SESSION_SETUP responses Moderate
Mariner CVE-2026-99274 smb: client: fix fiemap wild read on empty truncated response Moderate
Mariner CVE-2026-99273 ksmbd: reserve space for the UTF-16 terminator in stream info Moderate
Mariner CVE-2026-99268 io_uring: wake ring pollers for local task_work Low
Mariner CVE-2026-99260 ntfs: fix resident conversion in ntfs_new_attr_flags Low
Mariner CVE-2026-99256 dm cache: fix issue with background work locking Low
Mariner CVE-2026-99255 io_uring/io-wq: don't hide a link from cancellations Moderate
Mariner CVE-2026-99263 io_uring/poll: avoid retry wakeup loss when dropping ownership Low
Mariner CVE-2026-99262 io_uring/timeout: don't lose a cancel as io-wq arms a timeout Moderate
Mariner CVE-2026-99261 drm/amdgpu: correct reservation fence slots for userq per-vm BOs eviction Low
Mariner CVE-2026-99224 keys: Protect the type name while describing a key Moderate
Microsoft 365 Agents SDK CVE-2026-109485 Microsoft 365 Agents SDK Information Disclosure Vulnerability Important
Microsoft Account CVE-2026-112982 Microsoft Account Tampering Vulnerability Important
Microsoft Account CVE-2026-112974 Microsoft Account Tampering Vulnerability Important
Microsoft ActiveX Installer Service CVE-2026-96158 Microsoft ActiveX Installer Service Elevation of Privilege Vulnerability Important
Microsoft Authentication Library (MSAL) for Node.js CVE-2026-108470 Microsoft Authentication Library (MSAL) for Node.js Information Disclosure Vulnerability Important
Microsoft Authentication Library for JavaScript CVE-2026-108469 Microsoft Authentication Library for JavaScript Spoofing Vulnerability Important
Microsoft Azure Kubernetes Service CVE-2026-122986 Microsoft Azure Kubernetes Service Elevation of Privilege Vulnerability Important
Microsoft Bluetooth Driver CVE-2026-70120 Microsoft Bluetooth Driver Elevation of Privilege Vulnerability Important
Microsoft Color Management CVE-2026-96067 Microsoft Color Management Remote Code Execution Vulnerability Important
Microsoft Color Management CVE-2026-96054 Microsoft Color Management Remote Code Execution Vulnerability Important
Microsoft Color Management CVE-2026-96078 Microsoft Color Management Remote Code Execution Vulnerability Important
Microsoft Configuration Manager CVE-2026-119991 Microsoft Configuration Manager Information Disclosure Vulnerability Important
Microsoft Defender CVE-2026-122194 Microsoft Defender Remote Code Execution Vulnerability Critical
Microsoft Dynamics 365 (on-premises) CVE-2026-122196 Microsoft Dynamics 365 (on-premises) Information Disclosure Vulnerability Important
Microsoft Edge (Chromium-based) CVE-2026-121252 Chromium CVE-2026-121252: Incorrect authorization Low
Microsoft Edge (Chromium-based) CVE-2026-121251 Chromium CVE-2026-121251: Missing authorization Low
Microsoft Edge (Chromium-based) CVE-2026-121224 Chromium CVE-2026-121224: Security issue Important
Microsoft Edge (Chromium-based) CVE-2026-121087 Chromium CVE-2026-121087: Improper input validation Important
Microsoft Edge (Chromium-based) CVE-2026-121227 Chromium CVE-2026-121227: Uninitialized resource Important
Microsoft Edge (Chromium-based) CVE-2026-121084 Chromium CVE-2026-121084: Out of bounds read Important
Microsoft Edge (Chromium-based) CVE-2026-121255 Chromium CVE-2026-121255: Incorrect authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121083 Chromium CVE-2026-121083: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121081 Chromium CVE-2026-121081: UI misrepresentation Low
Microsoft Edge (Chromium-based) CVE-2026-121082 Chromium CVE-2026-121082: Type confusion Important
Microsoft Edge (Chromium-based) CVE-2026-121085 Chromium CVE-2026-121085: Incorrect authorization Low
Microsoft Edge (Chromium-based) CVE-2026-121228 Chromium CVE-2026-121228: Type confusion Important
Microsoft Edge (Chromium-based) CVE-2026-121226 Chromium CVE-2026-121226: Type confusion Important
Microsoft Edge (Chromium-based) CVE-2026-121253 Chromium CVE-2026-121253: Missing authorization Low
Microsoft Edge (Chromium-based) CVE-2026-121254 Chromium CVE-2026-121254: Information leak Moderate
Microsoft Edge (Chromium-based) CVE-2026-121086 Chromium CVE-2026-121086: Buffer overflow Important
Microsoft Edge (Chromium-based) CVE-2026-121248 Chromium CVE-2026-121248: Incorrect authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121245 Chromium CVE-2026-121245: Race condition Moderate
Microsoft Edge (Chromium-based) CVE-2026-121214 Chromium CVE-2026-121214: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121089 Chromium CVE-2026-121089: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121091 Chromium CVE-2026-121091: Incorrect authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121092 Chromium CVE-2026-121092: Uncontrolled recursion Low
Microsoft Edge (Chromium-based) CVE-2026-121095 Chromium CVE-2026-121095: Uninitialized resource Important
Microsoft Edge (Chromium-based) CVE-2026-121243 Chromium CVE-2026-121243: Information leak Low
Microsoft Edge (Chromium-based) CVE-2026-121094 Chromium CVE-2026-121094: Type confusion Important
Microsoft Edge (Chromium-based) CVE-2026-121093 Chromium CVE-2026-121093: Out of bounds read Low
Microsoft Edge (Chromium-based) CVE-2026-121244 Chromium CVE-2026-121244: UI misrepresentation Moderate
Microsoft Edge (Chromium-based) CVE-2026-121215 Chromium CVE-2026-121215: UI misrepresentation Moderate
Microsoft Edge (Chromium-based) CVE-2026-121249 Chromium CVE-2026-121249: Buffer overflow Important
Microsoft Edge (Chromium-based) CVE-2026-121221 Chromium CVE-2026-121221: Type confusion Important
Microsoft Edge (Chromium-based) CVE-2026-121250 Chromium CVE-2026-121250: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121223 Chromium CVE-2026-121223: Observable discrepancy Moderate
Microsoft Edge (Chromium-based) CVE-2026-121222 Chromium CVE-2026-121222: Incorrect authorization Low
Microsoft Edge (Chromium-based) CVE-2026-121088 Chromium CVE-2026-121088: Missing authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121217 Chromium CVE-2026-121217: Use after free Low
Microsoft Edge (Chromium-based) CVE-2026-121216 Chromium CVE-2026-121216: UI misrepresentation Moderate
Microsoft Edge (Chromium-based) CVE-2026-121218 Chromium CVE-2026-121218: Type confusion Moderate
Microsoft Edge (Chromium-based) CVE-2026-121220 Chromium CVE-2026-121220: Incorrect authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121219 Chromium CVE-2026-121219: Integer overflow Moderate
Microsoft Edge (Chromium-based) CVE-2026-119270 Chromium CVE-2026-119270: Improper input validation Important
Microsoft Edge (Chromium-based) CVE-2026-119271 Chromium CVE-2026-119271: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-119269 Chromium CVE-2026-119269: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-119267 Chromium CVE-2026-119267: Memory corruption Important
Microsoft Edge (Chromium-based) CVE-2026-119268 Chromium CVE-2026-119268: Integer overflow Important
Microsoft Edge (Chromium-based) CVE-2026-119272 Chromium CVE-2026-119272: Out of bounds read Moderate
Microsoft Edge (Chromium-based) CVE-2026-76029 Chromium CVE-2026-76029: Memory corruption Important
Microsoft Edge (Chromium-based) CVE-2026-76028 Chromium CVE-2026-76028: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-76030 Chromium CVE-2026-76030: Memory corruption Important
Microsoft Edge (Chromium-based) CVE-2026-122518 Microsoft Edge (Chromium-based) Information Disclosure Vulnerability Moderate
Microsoft Edge (Chromium-based) CVE-2026-76031 Chromium CVE-2026-76031: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-118321 Chromium CVE-2026-118321: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-119260 Chromium CVE-2026-119260: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-118314 Chromium CVE-2026-118314: Incorrect reference resolution Important
Microsoft Edge (Chromium-based) CVE-2026-121206 Chromium CVE-2026-121206: UI misrepresentation Low
Microsoft Edge (Chromium-based) CVE-2026-118309 Chromium CVE-2026-118309: Incorrect reference resolution Important
Microsoft Edge (Chromium-based) CVE-2026-119261 Chromium CVE-2026-119261: Improper input validation Important
Microsoft Edge (Chromium-based) CVE-2026-119265 Chromium CVE-2026-119265: Memory corruption Important
Microsoft Edge (Chromium-based) CVE-2026-119266 Chromium CVE-2026-119266: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-119264 Chromium CVE-2026-119264: Memory corruption Important
Microsoft Edge (Chromium-based) CVE-2026-119262 Chromium CVE-2026-119262: Improper input validation Important
Microsoft Edge (Chromium-based) CVE-2026-119263 Chromium CVE-2026-119263: Memory corruption Important
Microsoft Edge (Chromium-based) CVE-2026-121037 Chromium CVE-2026-121037: Out of bounds write Important
Microsoft Edge (Chromium-based) CVE-2026-121256 Chromium CVE-2026-121256: Use of released resource Moderate
Microsoft Edge (Chromium-based) CVE-2026-121036 Chromium CVE-2026-121036: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121034 Chromium CVE-2026-121034: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121035 Chromium CVE-2026-121035: Use after free Critical
Microsoft Edge (Chromium-based) CVE-2026-121038 Chromium CVE-2026-121038: Information leak Important
Microsoft Edge (Chromium-based) CVE-2026-121079 Chromium CVE-2026-121079: Race condition Important
Microsoft Edge (Chromium-based) CVE-2026-121080 Chromium CVE-2026-121080: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121078 Chromium CVE-2026-121078: Type confusion Important
Microsoft Edge (Chromium-based) CVE-2026-121039 Chromium CVE-2026-121039: Incorrect authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121050 Chromium CVE-2026-121050: Race condition Low
Microsoft Edge (Chromium-based) CVE-2026-76024 Chromium CVE-2026-76024: Memory corruption Critical
Microsoft Edge (Chromium-based) CVE-2026-121230 Chromium CVE-2026-121230: Race condition Low
Microsoft Edge (Chromium-based) CVE-2026-76025 Chromium CVE-2026-76025: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-76027 Chromium CVE-2026-76027: Memory corruption Important
Microsoft Edge (Chromium-based) CVE-2026-76026 Chromium CVE-2026-76026: Memory corruption Important
Microsoft Edge (Chromium-based) CVE-2026-121257 Chromium CVE-2026-121257: Use after free Moderate
Microsoft Edge (Chromium-based) CVE-2026-121031 Chromium CVE-2026-121031: Missing authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121032 Chromium CVE-2026-121032: Out of bounds read Important
Microsoft Edge (Chromium-based) CVE-2026-121030 Chromium CVE-2026-121030: Incorrect authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-120930 Chromium CVE-2026-120930: Incorrect authorization Important
Microsoft Edge (Chromium-based) CVE-2026-121029 Chromium CVE-2026-121029: Incorrect authorization Low
Microsoft Edge (Chromium-based) CVE-2026-121135 Chromium CVE-2026-121135: Security issue Moderate
Microsoft Edge (Chromium-based) CVE-2026-121136 Chromium CVE-2026-121136: Missing authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121134 Chromium CVE-2026-121134: Information loss Low
Microsoft Edge (Chromium-based) CVE-2026-121132 Chromium CVE-2026-121132: Information leak Moderate
Microsoft Edge (Chromium-based) CVE-2026-121133 Chromium CVE-2026-121133: Incorrect reference resolution Important
Microsoft Edge (Chromium-based) CVE-2026-121137 Chromium CVE-2026-121137: Type confusion Important
Microsoft Edge (Chromium-based) CVE-2026-121176 Chromium CVE-2026-121176: Uninitialized resource Moderate
Microsoft Edge (Chromium-based) CVE-2026-121178 Chromium CVE-2026-121178: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121175 Chromium CVE-2026-121175: Improper resource exposure Low
Microsoft Edge (Chromium-based) CVE-2026-121138 Chromium CVE-2026-121138: Observable discrepancy Low
Microsoft Edge (Chromium-based) CVE-2026-121174 Chromium CVE-2026-121174: Missing authorization Important
Microsoft Edge (Chromium-based) CVE-2026-121124 Chromium CVE-2026-121124: Improper adherence to coding standards Important
Microsoft Edge (Chromium-based) CVE-2026-121125 Chromium CVE-2026-121125: Information leak Low
Microsoft Edge (Chromium-based) CVE-2026-121123 Chromium CVE-2026-121123: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121121 Chromium CVE-2026-121121: UI misrepresentation Low
Microsoft Edge (Chromium-based) CVE-2026-121122 Chromium CVE-2026-121122: UI misrepresentation Moderate
Microsoft Edge (Chromium-based) CVE-2026-121126 Chromium CVE-2026-121126: Use after free Critical
Microsoft Edge (Chromium-based) CVE-2026-121130 Chromium CVE-2026-121130: Observable discrepancy Low
Microsoft Edge (Chromium-based) CVE-2026-121131 Chromium CVE-2026-121131: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121129 Chromium CVE-2026-121129: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121127 Chromium CVE-2026-121127: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121128 Chromium CVE-2026-121128: Use after free Moderate
Microsoft Edge (Chromium-based) CVE-2026-121179 Chromium CVE-2026-121179: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121198 Chromium CVE-2026-121198: Confused deputy Low
Microsoft Edge (Chromium-based) CVE-2026-121199 Chromium CVE-2026-121199: Missing authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121197 Chromium CVE-2026-121197: Out of bounds read Important
Microsoft Edge (Chromium-based) CVE-2026-121194 Chromium CVE-2026-121194: Missing authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121195 Chromium CVE-2026-121195: Incorrect authorization Low
Microsoft Edge (Chromium-based) CVE-2026-121200 Chromium CVE-2026-121200: Incorrect reference resolution Moderate
Microsoft Edge (Chromium-based) CVE-2026-121204 Chromium CVE-2026-121204: Incomplete cleanup Low
Microsoft Edge (Chromium-based) CVE-2026-121205 Chromium CVE-2026-121205: Incorrect authorization Low
Microsoft Edge (Chromium-based) CVE-2026-121203 Chromium CVE-2026-121203: Use after free Critical
Microsoft Edge (Chromium-based) CVE-2026-121201 Chromium CVE-2026-121201: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121202 Chromium CVE-2026-121202: Use after free Moderate
Microsoft Edge (Chromium-based) CVE-2026-121183 Chromium CVE-2026-121183: Incorrect authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121184 Chromium CVE-2026-121184: Out of bounds read Moderate
Microsoft Edge (Chromium-based) CVE-2026-121182 Chromium CVE-2026-121182: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121180 Chromium CVE-2026-121180: Buffer overflow Important
Microsoft Edge (Chromium-based) CVE-2026-121181 Chromium CVE-2026-121181: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121185 Chromium CVE-2026-121185: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121190 Chromium CVE-2026-121190: UI misrepresentation Low
Microsoft Edge (Chromium-based) CVE-2026-121193 Chromium CVE-2026-121193: Incorrect authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121189 Chromium CVE-2026-121189: Use after free Low
Microsoft Edge (Chromium-based) CVE-2026-121187 Chromium CVE-2026-121187: Observable discrepancy Moderate
Microsoft Edge (Chromium-based) CVE-2026-121188 Chromium CVE-2026-121188: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121120 Chromium CVE-2026-121120: Improper input validation Moderate
Microsoft Edge (Chromium-based) CVE-2026-121101 Chromium CVE-2026-121101: Missing authorization Low
Microsoft Edge (Chromium-based) CVE-2026-121209 Chromium CVE-2026-121209: UI misrepresentation Low
Microsoft Edge (Chromium-based) CVE-2026-121235 Chromium CVE-2026-121235: Information leak Low
Microsoft Edge (Chromium-based) CVE-2026-121211 Chromium CVE-2026-121211: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121100 Chromium CVE-2026-121100: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121210 Chromium CVE-2026-121210: Type confusion Important
Microsoft Edge (Chromium-based) CVE-2026-121208 Chromium CVE-2026-121208: Out of bounds read Important
Microsoft Edge (Chromium-based) CVE-2026-121231 Chromium CVE-2026-121231: Incorrect authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121207 Chromium CVE-2026-121207: Uninitialized resource Important
Microsoft Edge (Chromium-based) CVE-2026-121233 Chromium CVE-2026-121233: Type confusion Important
Microsoft Edge (Chromium-based) CVE-2026-121102 Chromium CVE-2026-121102: Missing authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121232 Chromium CVE-2026-121232: Incorrect authorization Low
Microsoft Edge (Chromium-based) CVE-2026-121213 Chromium CVE-2026-121213: Uninitialized resource Important
Microsoft Edge (Chromium-based) CVE-2026-121212 Chromium CVE-2026-121212: Incorrect authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121097 Chromium CVE-2026-121097: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121242 Chromium CVE-2026-121242: Improper input validation Moderate
Microsoft Edge (Chromium-based) CVE-2026-121240 Chromium CVE-2026-121240: Improper input validation Low
Microsoft Edge (Chromium-based) CVE-2026-121096 Chromium CVE-2026-121096: Incomplete cleanup Moderate
Microsoft Edge (Chromium-based) CVE-2026-121237 Chromium CVE-2026-121237: Improper state validation Moderate
Microsoft Edge (Chromium-based) CVE-2026-121236 Chromium CVE-2026-121236: Improper input validation Low
Microsoft Edge (Chromium-based) CVE-2026-121099 Chromium CVE-2026-121099: Information leak Moderate
Microsoft Edge (Chromium-based) CVE-2026-121239 Chromium CVE-2026-121239: Information leak Moderate
Microsoft Edge (Chromium-based) CVE-2026-121238 Chromium CVE-2026-121238: Use after free Moderate
Microsoft Edge (Chromium-based) CVE-2026-121098 Chromium CVE-2026-121098: Improper state validation Important
Microsoft Edge (Chromium-based) CVE-2026-121113 Chromium CVE-2026-121113: Buffer overflow Important
Microsoft Edge (Chromium-based) CVE-2026-121111 Chromium CVE-2026-121111: Incorrect authorization Low
Microsoft Edge (Chromium-based) CVE-2026-121104 Chromium CVE-2026-121104: Incorrect authorization Important
Microsoft Edge (Chromium-based) CVE-2026-121115 Chromium CVE-2026-121115: Improper input validation Moderate
Microsoft Edge (Chromium-based) CVE-2026-121114 Chromium CVE-2026-121114: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121103 Chromium CVE-2026-121103: Incorrect authorization Moderate
Microsoft Edge (Chromium-based) CVE-2026-121105 Chromium CVE-2026-121105: Information leak Moderate
Microsoft Edge (Chromium-based) CVE-2026-121107 Chromium CVE-2026-121107: Incorrect authorization Important
Microsoft Edge (Chromium-based) CVE-2026-121109 Chromium CVE-2026-121109: Inadequate encryption strength Low
Microsoft Edge (Chromium-based) CVE-2026-121108 Chromium CVE-2026-121108: Confused deputy Moderate
Microsoft Edge (Chromium-based) CVE-2026-121118 Chromium CVE-2026-121118: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121119 Chromium CVE-2026-121119: Use after free Important
Microsoft Edge (Chromium-based) CVE-2026-121117 Chromium CVE-2026-121117: Use after free Important
Microsoft Entra Private Network Connector CVE-2026-109460 Microsoft Entra Private Network Connector Information Disclosure Vulnerability Important
Microsoft Exchange Server CVE-2026-118149 Microsoft Exchange Server Remote Code Execution Vulnerability Important
Microsoft Exchange Server CVE-2026-118150 Microsoft Exchange Server Elevation of Privilege Vulnerability Important
Microsoft Exchange Server CVE-2026-118151 Microsoft Exchange Server Elevation of Privilege Vulnerability Important
Microsoft Exchange Server CVE-2026-118152 Microsoft Exchange Server Spoofing Vulnerability Important
Microsoft Exchange Server CVE-2026-118208 Microsoft Exchange Server Spoofing Vulnerability Important
Microsoft Exchange Server CVE-2026-118207 Microsoft Exchange Server Remote Code Execution Vulnerability Critical
Microsoft Exchange Server CVE-2026-118157 Microsoft Exchange Server Elevation of Privilege Vulnerability Important
Microsoft Exchange Server CVE-2026-118153 Microsoft Exchange Server Denial of Service Vulnerability Important
Microsoft Exchange Server CVE-2026-118154 Microsoft Exchange Server Elevation of Privilege Vulnerability Important
Microsoft Graph CVE-2026-114162 Microsoft Graph Elevation of Privilege Vulnerability Important
Microsoft Graphics Component CVE-2026-112754 Microsoft Graphics Component Information Disclosure Vulnerability Important
Microsoft High Performance Computing (HPC) Pack CVE-2026-122987 Microsoft High Performance Computing (HPC) Pack Elevation of Privilege Vulnerability Important
Microsoft Input Method Editor (IME) CVE-2026-105505 Microsoft Input Method Editor (IME) Elevation of Privilege Vulnerability Important
Microsoft JScript CVE-2026-112985 Windows JScript Remote Code Execution Vulnerability Important
Microsoft JScript CVE-2026-105578 Microsoft JScript Remote Code Execution Vulnerability Important
Microsoft Local Security Authority Server (lsasrv) CVE-2026-112807 Windows Local Security Authority Subsystem Service (LSASS) Denial of Service Vulnerability Important
Microsoft MCP Gateway CVE-2026-109492 Microsoft MCP Gateway Elevation of Privilege Vulnerability Important
Microsoft Office CVE-2026-112731 Microsoft Office Information Disclosure Vulnerability Important
Microsoft Office CVE-2026-120003 Microsoft Office Remote Code Execution Vulnerability Critical
Microsoft Office CVE-2026-116717 Microsoft Office Remote Code Execution Vulnerability Important
Microsoft Office CVE-2026-122198 Microsoft Office Remote Code Execution Vulnerability Important
Microsoft Office CVE-2026-111293 Microsoft Office Information Disclosure Vulnerability Important
Microsoft Office CVE-2026-119998 Microsoft Office Security Feature Bypass Vulnerability Important
Microsoft Office CVE-2026-111291 Microsoft Office Information Disclosure Vulnerability Important
Microsoft Office CVE-2026-111286 Microsoft Office Remote Code Execution Vulnerability Important
Microsoft Office CVE-2026-111289 Microsoft Office Remote Code Execution Vulnerability Critical
Microsoft Office Access CVE-2026-110059 Microsoft Office Access Remote Code Execution Vulnerability Important
Microsoft Office Access CVE-2026-110058 Microsoft Office Access Remote Code Execution Vulnerability Important
Microsoft Office Access CVE-2026-111301 Microsoft Office Access Remote Code Execution Vulnerability Important
Microsoft Office Access CVE-2026-109493 Microsoft Office Access Remote Code Execution Vulnerability Important
Microsoft Office Access CVE-2026-109498 Microsoft Office Access Remote Code Execution Vulnerability Important
Microsoft Office Access CVE-2026-111305 Microsoft Office Access Remote Code Execution Vulnerability Important
Microsoft Office Access CVE-2026-110060 Microsoft Office Access Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-124183 Microsoft Office Excel Information Disclosure Vulnerability Important
Microsoft Office Excel CVE-2026-118301 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118302 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118297 Microsoft Office Excel Remote Code Execution Vulnerability Critical
Microsoft Office Excel CVE-2026-118298 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118300 Microsoft Office Excel Information Disclosure Vulnerability Important
Microsoft Office Excel CVE-2026-118299 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-124187 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118703 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118704 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118705 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118702 Microsoft Office Excel Remote Code Execution Vulnerability Critical
Microsoft Office Excel CVE-2026-124229 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118700 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118701 Microsoft Office Excel Remote Code Execution Vulnerability Critical
Microsoft Office Excel CVE-2026-123395 Microsoft Office Excel Information Disclosure Vulnerability Important
Microsoft Office Excel CVE-2026-124170 Microsoft Office Excel Remote Code Execution Vulnerability Critical
Microsoft Office Excel CVE-2026-124174 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-119986 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118728 Microsoft Office Excel Information Disclosure Vulnerability Important
Microsoft Office Excel CVE-2026-119999 Microsoft Office Excel Information Disclosure Vulnerability Important
Microsoft Office Excel CVE-2026-123385 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-124176 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118294 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118295 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118296 Microsoft Office Excel Remote Code Execution Vulnerability Critical
Microsoft Office Excel CVE-2026-118293 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-124178 Microsoft Office Excel Information Disclosure Vulnerability Important
Microsoft Office Excel CVE-2026-124179 Microsoft Office Excel Information Disclosure Vulnerability Important
Microsoft Office Excel CVE-2026-118292 Microsoft Office Excel Remote Code Execution Vulnerability Critical
Microsoft Office Excel CVE-2026-118727 Microsoft Office Excel Information Disclosure Vulnerability Important
Microsoft Office Excel CVE-2026-118726 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118729 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-120785 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118723 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118722 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118725 Microsoft Office Excel Elevation of Privilege Vulnerability Important
Microsoft Office Excel CVE-2026-118724 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-120789 Microsoft Office Excel Remote Code Execution Vulnerability Critical
Microsoft Office Excel CVE-2026-120788 Microsoft Office Excel Remote Code Execution Vulnerability Critical
Microsoft Office Excel CVE-2026-120791 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-120790 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-120786 Microsoft Office Excel Remote Code Execution Vulnerability Critical
Microsoft Office Excel CVE-2026-118730 Microsoft Office Excel Remote Code Execution Vulnerability Critical
Microsoft Office Excel CVE-2026-118732 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118731 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118711 Microsoft Office Excel Remote Code Execution Vulnerability Critical
Microsoft Office Excel CVE-2026-118710 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118713 Microsoft Office Excel Remote Code Execution Vulnerability Critical
Microsoft Office Excel CVE-2026-118712 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118707 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118706 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118709 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118708 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118719 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118718 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118721 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118720 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118715 Microsoft Office Excel Elevation of Privilege Vulnerability Important
Microsoft Office Excel CVE-2026-118714 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118717 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-118716 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-116927 Microsoft Office Excel Remote Code Execution Vulnerability Important
Microsoft Office Excel CVE-2026-111292 Microsoft Office Excel Information Disclosure Vulnerability Important
Microsoft Office Outlook CVE-2026-119997 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-123382 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-123381 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-123378 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-123379 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-123380 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-124227 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-124228 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-110043 Microsoft Office Outlook Remote Code Execution Vulnerability Critical
Microsoft Office Outlook CVE-2026-124194 Microsoft Outlook Spoofing Vulnerability Moderate
Microsoft Office Outlook CVE-2026-111309 Microsoft Office Outlook Remote Code Execution Vulnerability Critical
Microsoft Office Outlook CVE-2026-123383 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-123384 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-123377 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-123375 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-123376 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-110068 Microsoft Office Outlook Remote Code Execution Vulnerability Critical
Microsoft Office Outlook CVE-2026-119993 Microsoft Office Outlook Information Disclosure Vulnerability Important
Microsoft Office Outlook CVE-2026-119995 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office Outlook CVE-2026-119996 Microsoft Office Outlook Remote Code Execution Vulnerability Important
Microsoft Office PowerPoint CVE-2026-120001 Microsoft Office PowerPoint Remote Code Execution Vulnerability Important
Microsoft Office PowerPoint CVE-2026-120005 Microsoft PowerPoint Remote Code Execution Vulnerability Critical
Microsoft Office PowerPoint CVE-2026-112734 Microsoft Office PowerPoint Remote Code Execution Vulnerability Important
Microsoft Office PowerPoint CVE-2026-112738 Microsoft Office PowerPoint Information Disclosure Vulnerability Important
Microsoft Office PowerPoint CVE-2026-112737 Microsoft Office PowerPoint Remote Code Execution Vulnerability Important
Microsoft Office PowerPoint CVE-2026-109487 Microsoft PowerPoint Remote Code Execution Vulnerability Important
Microsoft Office PowerPoint CVE-2026-116922 Microsoft Office PowerPoint Information Disclosure Vulnerability Important
Microsoft Office SharePoint CVE-2026-111300 Microsoft Office SharePoint Spoofing Vulnerability Important
Microsoft Office SharePoint CVE-2026-88176 Microsoft Office SharePoint Elevation of Privilege Vulnerability Important
Microsoft Office SharePoint CVE-2026-109504 Microsoft Office SharePoint Spoofing Vulnerability Important
Microsoft Office SharePoint CVE-2026-109456 Microsoft Office SharePoint Spoofing Vulnerability Important
Microsoft Office SharePoint CVE-2026-111303 Microsoft Office SharePoint Spoofing Vulnerability Important
Microsoft Office SharePoint CVE-2026-109497 Microsoft Office SharePoint Spoofing Vulnerability Important
Microsoft Office SharePoint CVE-2026-110044 Microsoft Office SharePoint Remote Code Execution Vulnerability Important
Microsoft Office SharePoint CVE-2026-110045 Microsoft Office SharePoint Spoofing Vulnerability Important
Microsoft Office SharePoint CVE-2026-109455 Microsoft Office SharePoint Information Disclosure Vulnerability Important
Microsoft Office SharePoint CVE-2026-109499 Microsoft Office SharePoint Remote Code Execution Vulnerability Important
Microsoft Office SharePoint CVE-2026-109495 Microsoft Office SharePoint Elevation of Privilege Vulnerability Important
Microsoft Office SharePoint CVE-2026-111297 Microsoft Office SharePoint Spoofing Vulnerability Important
Microsoft Office SharePoint CVE-2026-109472 Microsoft Office SharePoint Remote Code Execution Vulnerability Important
Microsoft Office SharePoint CVE-2026-109466 Microsoft Office SharePoint Elevation of Privilege Vulnerability Important
Microsoft Office SharePoint CVE-2026-111296 Microsoft Office SharePoint Elevation of Privilege Vulnerability Important
Microsoft Office SharePoint CVE-2026-109502 Microsoft Office SharePoint Elevation of Privilege Vulnerability Important
Microsoft Office SharePoint CVE-2026-80095 Microsoft Office SharePoint Elevation of Privilege Vulnerability Important
Microsoft Office SharePoint CVE-2026-109454 Microsoft Office SharePoint Spoofing Vulnerability Important
Microsoft Office SharePoint CVE-2026-112736 Microsoft Office SharePoint Spoofing Vulnerability Important
Microsoft Office SharePoint CVE-2026-120002 Microsoft SharePoint Server Elevation of Privilege Vulnerability Important
Microsoft Office SharePoint CVE-2026-123391 Microsoft Office SharePoint Elevation of Privilege Vulnerability Important
Microsoft Office SharePoint CVE-2026-124210 Microsoft Office SharePoint Information Disclosure Vulnerability Important
Microsoft Office SharePoint CVE-2026-123390 Microsoft Office SharePoint Remote Code Execution Vulnerability Important
Microsoft Office SharePoint CVE-2026-120000 Microsoft Office SharePoint Remote Code Execution Vulnerability Important
Microsoft Office SharePoint CVE-2026-109464 Microsoft Office SharePoint Remote Code Execution Vulnerability Important
Microsoft Office SharePoint CVE-2026-110057 Microsoft Office SharePoint Information Disclosure Vulnerability Important
Microsoft Office SharePoint CVE-2026-110065 Microsoft Office SharePoint Spoofing Vulnerability Important
Microsoft Office Visio CVE-2026-109496 Microsoft Office Visio Remote Code Execution Vulnerability Important
Microsoft Office Visio CVE-2026-109494 Microsoft Office Visio Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-111287 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-111302 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-110047 Microsoft Office Word Remote Code Execution Vulnerability Critical
Microsoft Office Word CVE-2026-109491 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-110066 Microsoft Office Word Information Disclosure Vulnerability Important
Microsoft Office Word CVE-2026-111306 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-110067 Microsoft Office Word Remote Code Execution Vulnerability Critical
Microsoft Office Word CVE-2026-111285 Microsoft Office Word Remote Code Execution Vulnerability Critical
Microsoft Office Word CVE-2026-110062 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-110061 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-110064 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-111304 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-110056 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-110052 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-109505 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-111294 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-109503 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-110051 Microsoft Office Word Information Disclosure Vulnerability Important
Microsoft Office Word CVE-2026-110048 Microsoft Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-110046 Microsoft Office Word Information Disclosure Vulnerability Important
Microsoft Office Word CVE-2026-110050 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-110049 Microsoft Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-111298 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-110054 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-111299 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-111288 Microsoft Office Word Information Disclosure Vulnerability Important
Microsoft Office Word CVE-2026-109500 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-111295 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-111290 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-109501 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-110053 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112722 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112721 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112723 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112726 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112724 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112717 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112716 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112718 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112720 Microsoft Office Word Information Disclosure Vulnerability Important
Microsoft Office Word CVE-2026-112719 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112728 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-124233 Microsoft Office Word Information Disclosure Vulnerability Important
Microsoft Office Word CVE-2026-112741 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-113759 Microsoft Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-123394 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-124185 Microsoft Office Word Remote Code Execution Vulnerability Critical
Microsoft Office Word CVE-2026-112730 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112729 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112733 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112739 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112735 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-116925 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-116923 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-110055 Microsoft Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-111307 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-116722 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-116718 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-116719 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-111308 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-116721 Microsoft Office Word Information Disclosure Vulnerability Important
Microsoft Office Word CVE-2026-111310 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112715 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-116720 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft Office Word CVE-2026-112714 Microsoft Office Word Remote Code Execution Vulnerability Important
Microsoft PowerShell CVE-2026-122985 Microsoft PowerShell Information Disclosure Vulnerability Important
Microsoft PowerShell Core CVE-2026-121675 PowerShell Information Disclosure Vulnerability Important
Microsoft PowerShell Core CVE-2026-121669 PowerShell Information Disclosure Vulnerability Important
Microsoft PowerShell Core CVE-2026-121674 PowerShell Information Disclosure Vulnerability Important
Microsoft QUIC CVE-2026-88236 Microsoft QUIC Denial of Service Vulnerability Important
Microsoft QUIC CVE-2026-105512 Microsoft QUIC Denial of Service Vulnerability Important
Microsoft Remote Registry Service CVE-2026-105492 Microsoft Remote Registry Service Denial of Service Vulnerability Important
Microsoft Streaming Service CVE-2026-119937 Kernel Streaming Service Driver Elevation of Privilege Vulnerability Important
Microsoft Teams CVE-2026-116926 Microsoft Teams Spoofing Vulnerability Important
Microsoft Teams for Android CVE-2026-69901 Microsoft Teams for Android Spoofing Vulnerability Important
Microsoft Teams for Android CVE-2026-122979 Microsoft Teams for Android Spoofing Vulnerability Important
Microsoft Trace Data Helper CVE-2026-121681 Microsoft Trace Data Helper Elevation of Privilege Vulnerability Important
Microsoft Trace Data Helper CVE-2026-122172 Microsoft Trace Data Helper Elevation of Privilege Vulnerability Important
Microsoft WDAC OLE DB provider for SQL CVE-2026-85839 Microsoft WDAC OLE DB provider for SQL Remote Code Execution Vulnerability Important
Microsoft WDAC OLE DB provider for SQL CVE-2026-85838 Microsoft WDAC OLE DB provider for SQL Remote Code Execution Vulnerability Important
Microsoft WDAC OLE DB provider for SQL CVE-2026-88222 Microsoft WDAC OLE DB provider for SQL Remote Code Execution Vulnerability Important
Microsoft WDAC OLE DB provider for SQL CVE-2026-116698 Microsoft WDAC OLE DB provider for SQL Remote Code Execution Vulnerability Important
Microsoft WDAC OLE DB provider for SQL CVE-2026-116699 Microsoft WDAC OLE DB provider for SQL Remote Code Execution Vulnerability Important
Microsoft Windows App Store CVE-2026-119987 Microsoft Windows App Store Elevation of Privilege Vulnerability Important
Microsoft Windows Codecs Library CVE-2026-113749 Microsoft Windows Codecs Library Remote Code Execution Vulnerability Critical
Microsoft Windows Codecs Library CVE-2026-114167 HEVC Video Extensions Remote Code Execution Vulnerability Important
Microsoft Windows Codecs Library CVE-2026-114164 HEVC Video Extensions Remote Code Execution Vulnerability Important
Microsoft Windows Codecs Library CVE-2026-96150 Microsoft Windows Codecs Library Information Disclosure Vulnerability Important
Microsoft Windows Codecs Library CVE-2026-114165 HEVC Video Extensions Remote Code Execution Vulnerability Important
Microsoft Windows Media Foundation CVE-2026-96157 Microsoft Windows Media Foundation Remote Code Execution Vulnerability Important
Microsoft Windows Media Foundation CVE-2026-122168 Microsoft Windows Media Foundation Elevation of Privilege Vulnerability Important
Microsoft Windows SCSI Class System File CVE-2026-113821 Microsoft Windows SCSI Class System File Information Disclosure Vulnerability Important
Microsoft Windows SCSI Class System File CVE-2026-105586 Microsoft Windows SCSI Class System File Elevation of Privilege Vulnerability Important
Microsoft Windows Search Component CVE-2026-119954 Microsoft Windows Search Component Elevation of Privilege Vulnerability Important
Microsoft Windows Search Component CVE-2026-119943 Microsoft Windows Search Component Elevation of Privilege Vulnerability Important
Microsoft Windows Search Component CVE-2026-116928 Windows Search Remote Code Execution Vulnerability Critical
Microsoft Windows Speech CVE-2026-119904 Microsoft Windows Speech Elevation of Privilege Vulnerability Important
Microsoft XPS Document Converter CVE-2026-122171 Microsoft XPS Document Converter Remote Code Execution Vulnerability Important
Microsoft XPS Document Converter CVE-2026-119880 Microsoft XPS Document Converter Remote Code Execution Vulnerability Important
Microsoft XPS Document Converter CVE-2026-119881 Microsoft XPS Document Converter Elevation of Privilege Vulnerability Important
Quality Windows Audio/Video Experience (QWAVE) service CVE-2026-119387 Quality Windows Audio/Video Experience (QWAVE) service Elevation of Privilege Vulnerability Important
Quality Windows Audio/Video Experience (QWAVE) service CVE-2026-119388 Quality Windows Audio/Video Experience (QWAVE) service Elevation of Privilege Vulnerability Important
Quality Windows Audio/Video Experience (QWAVE) service CVE-2026-123389 Quality Windows Audio/Video Experience (QWAVE) service Elevation of Privilege Vulnerability Important
Reliable Multicast Transport Driver (RMCAST) CVE-2026-116697 Reliable Multicast Transport Driver (RMCAST) Denial of Service Vulnerability Important
Remote Desktop Client CVE-2026-119858 Remote Desktop Client Remote Code Execution Vulnerability Important
Remote Desktop Client CVE-2026-121677 Windows Remote Desktop Client Information Disclosure Vulnerability Important
Remote Desktop Client CVE-2026-108419 Windows Remote Desktop Client Information Disclosure Vulnerability Important
Remote Desktop Client CVE-2026-108418 Windows Remote Desktop Client Information Disclosure Vulnerability Important
Remote Desktop Client CVE-2026-108417 Windows Remote Desktop Client Information Disclosure Vulnerability Important
Remote Desktop Client CVE-2026-119934 Remote Desktop Client Remote Code Execution Vulnerability Important
Remote Desktop Client CVE-2026-95908 Windows Remote Desktop Client Information Disclosure Vulnerability Important
Remote Desktop Client CVE-2026-95964 Remote Desktop Client Remote Code Execution Vulnerability Important
Remote Desktop Client CVE-2026-119390 Remote Desktop Client Remote Code Execution Vulnerability Important
Remote Desktop Client CVE-2026-119839 Windows Remote Desktop Client Elevation of Privilege Vulnerability Important
Remote Desktop Client CVE-2026-119824 Remote Desktop Client Tampering Vulnerability Important
Remote Desktop Client CVE-2026-121678 Windows Remote Desktop Client Information Disclosure Vulnerability Important
Remote Desktop Gateway Service CVE-2026-69327 Windows Remote Desktop Services Remote Code Execution Vulnerability Important
Remote Desktop Gateway Service CVE-2026-80094 Remote Desktop Gateway Service Elevation of Privilege Vulnerability Important
Remote Desktop Gateway Service CVE-2026-69565 Windows Remote Desktop Services Remote Code Execution Vulnerability Important
Role: DNS Server CVE-2026-96020 Windows Domain Name Service Remote Code Execution Vulnerability Important
Role: DNS Server CVE-2026-112727 Windows Domain Name Service Remote Code Execution Vulnerability Important
Role: DNS Server CVE-2026-96177 Windows Domain Name Service Remote Code Execution Vulnerability Important
Role: DNS Server CVE-2026-96064 Windows Domain Name Service Remote Code Execution Vulnerability Important
Role: DNS Server CVE-2026-81384 Windows DNS Server Remote Code Execution Vulnerability Important
Role: DNS Server CVE-2026-96179 Windows DNS Elevation of Privilege Vulnerability Important
Role: DNS Server CVE-2026-96975 Role: DNS Server Denial of Service Vulnerability Important
Role: DNS Server CVE-2026-96112 Windows DNS Server Information Disclosure Vulnerability Important
Role: DNS Server CVE-2026-96017 Role: DNS Server Denial of Service Vulnerability Important
Role: DNS Server CVE-2026-96002 Windows Domain Name Service Remote Code Execution Vulnerability Important
Role: DNS Server CVE-2026-96092 Windows Domain Name Service Remote Code Execution Vulnerability Important
RPC Runtime CVE-2026-83894 RPC Runtime Elevation of Privilege Vulnerability Important
Secondary Logon CVE-2026-96989 Secondary Logon Information Disclosure Vulnerability Important
Servicing Stack Updates CVE-2026-88235 Servicing Stack Updates Elevation of Privilege Vulnerability Important
Servicing Stack Updates CVE-2026-112989 Windows Servicing Stack Updates Elevation of Privilege Vulnerability Important
Software Protection Platform (SPP) CVE-2026-113748 Software Protection Platform (SPP) Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-118111 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-118112 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-67391 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-68783 Microsoft SQL Server Information Disclosure Vulnerability Important
SQL Server CVE-2026-67387 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-118113 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-67646 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-67637 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-67632 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-118117 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-118115 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-118118 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-62903 Microsoft.Data.SqlClient Information Disclosure Vulnerability Important
SQL Server CVE-2026-118116 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-118120 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-118119 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-118114 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-67375 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-67382 Microsoft SQL Server Information Disclosure Vulnerability Important
SQL Server CVE-2026-66813 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-67372 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-67374 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-116936 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-116937 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-84010 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-116935 Microsoft SQL Server Information Disclosure Vulnerability Important
SQL Server CVE-2026-116940 Microsoft SQL Server Information Disclosure Vulnerability Important
SQL Server CVE-2026-116941 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-116938 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-116939 Microsoft SQL Server Information Disclosure Vulnerability Important
SQL Server CVE-2026-116934 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-88111 SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-116929 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-94511 SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-94513 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-116932 Microsoft SQL Server Information Disclosure Vulnerability Important
SQL Server CVE-2026-116933 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-116930 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-116931 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-118104 Microsoft SQL Server Information Disclosure Vulnerability Important
SQL Server CVE-2026-118105 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-118102 Microsoft SQL Server Information Disclosure Vulnerability Important
SQL Server CVE-2026-118103 Microsoft SQL Server Information Disclosure Vulnerability Important
SQL Server CVE-2026-118109 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-118110 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-118106 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-118108 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-116944 Microsoft SQL Server Elevation of Privilege Vulnerability Important
SQL Server CVE-2026-116945 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-116942 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-116943 Microsoft SQL Server Information Disclosure Vulnerability Important
SQL Server CVE-2026-116947 Microsoft SQL Server Remote Code Execution Vulnerability Important
SQL Server CVE-2026-116946 Microsoft SQL Server Remote Code Execution Vulnerability Important
Storport.sys Driver CVE-2026-119395 Storport.sys Driver Information Disclosure Vulnerability Important
vhdmp.sys CVE-2026-95989 vhdmp.sys Elevation of Privilege Vulnerability Important
Virtual Hard Disk (VHD) Miniport Driver CVE-2026-119849 Virtual Hard Disk (VHD) Miniport Driver Remote Code Execution Vulnerability Important
Visual Studio CVE-2026-114158 Visual Studio Remote Code Execution Vulnerability Important
Visual Studio CVE-2026-118745 Visual Studio Remote Code Execution Vulnerability Important
Visual Studio CVE-2026-114152 Visual Studio Remote Code Execution Vulnerability Important
Visual Studio CVE-2026-114151 Visual Studio Remote Code Execution Vulnerability Important
Visual Studio CVE-2026-114159 Visual Studio Remote Code Execution Vulnerability Important
Visual Studio Code CVE-2026-119975 Visual Studio Code Remote Code Execution Vulnerability Important
Visual Studio Code CVE-2026-70094 Visual Studio Code Remote Code Execution Vulnerability Important
Visual Studio Code CVE-2026-119983 Visual Studio Code Security Feature Bypass Vulnerability Important
Visual Studio Code CVE-2026-119985 Visual Studio Code Remote Code Execution Vulnerability Important
Visual Studio Code CVE-2026-119981 Visual Studio Code Elevation of Privilege Vulnerability Important
Visual Studio Code CVE-2026-119982 Visual Studio Code Security Feature Bypass Vulnerability Important
Visual Studio Code CVE-2026-102230 Visual Studio Code Information Disclosure Vulnerability Important
Visual Studio Code CVE-2026-120782 Visual Studio Code Security Feature Bypass Vulnerability Important
Visual Studio Code CVE-2026-120780 Visual Studio Code Remote Code Execution Vulnerability Important
Visual Studio Code CVE-2026-120779 Visual Studio Code Remote Code Execution Vulnerability Important
Visual Studio Code CVE-2026-102236 Visual Studio Code Security Feature Bypass Vulnerability Important
Visual Studio Code CVE-2026-121660 Visual Studio Code Security Feature Bypass Vulnerability Important
Visual Studio Code CVE-2026-121661 Visual Studio Code Security Feature Bypass Vulnerability Important
Visual Studio Code CVE-2026-121664 Visual Studio Code Remote Code Execution Vulnerability Important
Visual Studio Code CVE-2026-121665 Visual Studio Code Security Feature Bypass Vulnerability Important
Visual Studio Code CVE-2026-114171 Visual Studio Code Security Feature Bypass Vulnerability Important
Visual Studio Code CVE-2026-121663 Visual Studio Code Security Feature Bypass Vulnerability Important
Visual Studio Code CVE-2026-121662 Visual Studio Code Remote Code Execution Vulnerability Important
Visual Studio Code - GitHub Pull Requests and Issues Extension CVE-2026-119976 Visual Studio Code GitHub Pull Requests and Issues Extension Information Disclosure Vulnerability Important
Windows Active Directory CVE-2026-105559 Windows Active Directory Denial of Service Vulnerability Important
Windows Active Directory CVE-2026-123387 Active Directory Domain Services Elevation of Privilege Vulnerability Important
Windows Active Directory CVE-2026-119948 Windows Active Directory Remote Code Execution Vulnerability Important
Windows Active Directory Certificate Services CVE-2026-95884 Windows Active Directory Certificate Services Information Disclosure Vulnerability Important
Windows Active Directory Certificate Services CVE-2026-105590 Windows Active Directory Certificate Services Security Feature Bypass Important
Windows Admin Center CVE-2026-122988 Windows Admin Center Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118280 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118283 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105498 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105499 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118278 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118277 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118279 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105025 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105022 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105497 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105495 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105496 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105021 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105491 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-95960 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105020 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-94515 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118232 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118219 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105493 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118222 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118221 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118218 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118215 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118214 Windows Advanced Rasterization Platform Information Disclosure Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118217 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118216 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118223 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105026 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118226 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118227 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118229 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118228 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105490 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118224 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-105023 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Advanced Rasterization Platform CVE-2026-118225 Windows Advanced Rasterization Platform Elevation of Privilege Vulnerability Important
Windows Ancillary Function Driver for WinSock CVE-2026-88242 Windows Ancillary Function Driver for WinSock Elevation of Privilege Vulnerability Important
Windows App Readiness Service CVE-2026-95944 Windows App Readiness Service Tampering Vulnerability Important
Windows AppContainer CVE-2026-96018 Windows AppContainer Information Disclosure Vulnerability Important
Windows AppX Deployment Service CVE-2026-88224 Windows AppX Deployment Service Elevation of Privilege Vulnerability Important
Windows AppX Deployment Service CVE-2026-116714 Windows AppX Deployment Service Elevation of Privilege Vulnerability Important
Windows AppX Package Manager CVE-2026-96074 Windows AppX Package Manager Elevation of Privilege Vulnerability Important
Windows Audio Service CVE-2026-119895 Windows Audio Service Elevation of Privilege Vulnerability Important
Windows Audio Service CVE-2026-96155 Windows Audio Service Elevation of Privilege Vulnerability Important
Windows Audio Service CVE-2026-96038 Windows Audio Service Elevation of Privilege Vulnerability Important
Windows Audio Service CVE-2026-119894 Windows Audio Service Elevation of Privilege Vulnerability Important
Windows Audio Service CVE-2026-105541 Windows Audio Service Elevation of Privilege Vulnerability Important
Windows Audio Service CVE-2026-119888 Windows Audio Service Elevation of Privilege Vulnerability Important
Windows Audio Service CVE-2026-119893 Windows Audio Service Elevation of Privilege Vulnerability Important
Windows Audio Service CVE-2026-121671 Windows Audio Service Elevation of Privilege Vulnerability Important
Windows Autopilot CVE-2026-122175 Windows Autopilot Elevation of Privilege Vulnerability Important
Windows Background Intelligent Transfer Service (BITS) CVE-2026-105554 Windows Background Intelligent Transfer Service (BITS) Elevation of Privilege Vulnerability Important
Windows Backup Engine CVE-2026-119405 Windows Backup Engine Elevation of Privilege Vulnerability Important
Windows Bind Filter Driver CVE-2026-70182 Windows Bind Filter Driver Elevation of Privilege Vulnerability Important
Windows Biometric Service CVE-2026-96127 Windows Biometric Service Elevation of Privilege Vulnerability Important
Windows Biometric Service CVE-2026-95877 Windows Biometric Service Elevation of Privilege Vulnerability Important
Windows Biometric Service CVE-2026-88239 Windows Biometric Service Elevation of Privilege Vulnerability Important
Windows BitLocker CVE-2026-119832 Windows BitLocker Security Feature Bypass Vulnerability Important
Windows BitLocker CVE-2026-97015 Windows BitLocker Security Feature Bypass Vulnerability Important
Windows Bluetooth A2DP driver CVE-2026-88187 Windows Bluetooth A2DP driver Elevation of Privilege Vulnerability Important
Windows Bluetooth Port Driver CVE-2026-95996 Windows Bluetooth Port Driver Elevation of Privilege Vulnerability Important
Windows Bluetooth Service CVE-2026-88213 Windows Bluetooth Service Elevation of Privilege Vulnerability Important
Windows Bluetooth Service CVE-2026-96001 Windows Bluetooth Service Information Disclosure Vulnerability Important
Windows Broadcast DVR User Service CVE-2026-112761 Windows Broadcast DVR User Service Elevation of Privilege Vulnerability Important
Windows Broadcast DVR User Service CVE-2026-119401 Windows Broadcast DVR User Service Elevation of Privilege Vulnerability Important
Windows Broadcast DVR User Service CVE-2026-88221 Windows Broadcast DVR User Service Elevation of Privilege Vulnerability Important
Windows Broadcast DVR User Service CVE-2026-119402 Windows Broadcast DVR User Service Elevation of Privilege Vulnerability Important
Windows Broadcast DVR User Service CVE-2026-119403 Windows Broadcast DVR User Service Elevation of Privilege Vulnerability Important
Windows Broadcast DVR User Service CVE-2026-94529 Windows Broadcast DVR User Service Elevation of Privilege Vulnerability Important
Windows Broadcast DVR User Service CVE-2026-113762 Windows Broadcast DVR User Service Elevation of Privilege Vulnerability Important
Windows Broadcast DVR User Service CVE-2026-95871 Windows Broadcast DVR User Service Elevation of Privilege Vulnerability Important
Windows Broker Infrastructure Service CVE-2026-96156 Windows Broker Infrastructure Service Information Disclosure Vulnerability Important
Windows Brokering File System CVE-2026-95979 Windows Brokering File System Elevation of Privilege Vulnerability Important
Windows Brokering File System CVE-2026-88245 Windows Brokering File System Elevation of Privilege Vulnerability Important
Windows Brokering File System CVE-2026-85929 Microsoft Brokering File System Elevation of Privilege Vulnerability Important
Windows Brokering File System CVE-2026-96097 Windows Brokering File System Elevation of Privilege Vulnerability Important
Windows Camera Frame Server Monitor CVE-2026-88238 Windows Camera Frame Server Monitor Elevation of Privilege Vulnerability Important
Windows Camera Frame Server Monitor CVE-2026-85942 Windows Camera Frame Server Monitor Elevation of Privilege Vulnerability Important
Windows Camera Frame Server Monitor CVE-2026-88232 Windows Camera Frame Server Monitor Elevation of Privilege Vulnerability Important
Windows CD-ROM Driver CVE-2026-108404 Windows CD-ROM Driver Remote Code Execution Vulnerability Important
Windows CD-ROM Driver CVE-2026-108405 Windows CD-ROM Driver Elevation of Privilege Vulnerability Important
Windows Client for NFS CVE-2026-122165 Windows Client for NFS Elevation of Privilege Vulnerability Important
Windows Client for NFS CVE-2026-95885 Windows Client for NFS Elevation of Privilege Vulnerability Important
Windows Client for NFS CVE-2026-118141 Windows Client for NFS Remote Code Execution Vulnerability Important
Windows Client for NFS CVE-2026-88249 Windows Client for NFS Remote Code Execution Vulnerability Important
Windows Client for NFS CVE-2026-119404 Windows Client for NFS Security Feature Bypass Vulnerability Important
Windows Client for NFS CVE-2026-118138 Windows Client for NFS Elevation of Privilege Vulnerability Important
Windows Clipboard Virtual Channel Extension CVE-2026-96162 Windows Clipboard Virtual Channel Extension Elevation of Privilege Vulnerability Important
Windows Cloud Files Mini Filter Driver CVE-2026-112810 Windows Cloud Files Mini Filter Driver Elevation of Privilege Vulnerability Important
Windows Cloud Files Mini Filter Driver CVE-2026-112803 Windows Cloud Files Mini Filter Driver Information Disclosure Vulnerability Important
Windows Cloud Files Mini Filter Driver CVE-2026-105569 Windows Cloud Files Mini Filter Driver Elevation of Privilege Vulnerability Important
Windows Cloud Files Mini Filter Driver CVE-2026-119974 Windows Cloud Files Mini Filter Driver Elevation of Privilege Vulnerability Important
Windows Cloud Files Mini Filter Driver CVE-2026-112763 Windows Cloud Files Mini Filter Driver Elevation of Privilege Vulnerability Important
Windows CNG Key Isolation Service CVE-2026-103571 Windows CNG Key Isolation Service Elevation of Privilege Vulnerability Important
Windows COM CVE-2026-112968 Windows COM Elevation of Privilege Vulnerability Important
Windows COM CVE-2026-105533 Windows COM Elevation of Privilege Vulnerability Important
Windows COM CVE-2026-94531 Windows COM Elevation of Privilege Vulnerability Important
Windows COM+ Event System Service CVE-2026-113767 Windows COM+ Event System Service Elevation of Privilege Vulnerability Important
Windows COM+ Event System Service CVE-2026-113769 Windows COM+ Event System Service Elevation of Privilege Vulnerability Important
Windows COM+ Event System Service CVE-2026-119855 Windows COM+ Event System Service Information Disclosure Vulnerability Important
Windows Composite Image File System CVE-2026-112809 Windows Composite Image File System Information Disclosure Vulnerability Important
Windows Connected User Experiences and Telemetry CVE-2026-96072 Windows Connected User Experiences and Telemetry Elevation of Privilege Vulnerability Important
Windows Connected User Experiences and Telemetry CVE-2026-96101 Windows Connected User Experiences and Telemetry Information Disclosure Vulnerability Important
Windows Connected User Experiences and Telemetry CVE-2026-96088 Windows Connected User Experiences and Telemetry Elevation of Privilege Vulnerability Important
Windows Connection Manager Service CVE-2026-96043 Windows Connection Manager Service Elevation of Privilege Vulnerability Important
Windows Connection Manager Service CVE-2026-96042 Windows Connection Manager Service Elevation of Privilege Vulnerability Important
Windows Container Isolation FS Filter Driver (unionfs.sys) CVE-2026-112753 Windows Container Isolation FS Filter Driver (unionfs.sys) Elevation of Privilege Vulnerability Important
Windows Container Isolation FS Filter Driver (unionfs.sys) CVE-2026-113761 Windows Container Isolation FS Filter Driver (unionfs.sys) Elevation of Privilege Vulnerability Important
Windows Container Isolation FS Filter Driver (unionfs.sys) CVE-2026-113771 Windows Container Isolation FS Filter Driver (unionfs.sys) Elevation of Privilege Vulnerability Important
Windows Container Manager Service CVE-2026-105562 Windows Container Manager Service Information Disclosure Vulnerability Important
Windows Cred SSProvider Protocol CVE-2026-119962 Windows CredSSP Remote Code Execution Vulnerability Critical
Windows Credential Manager CVE-2026-119393 Windows Credential Manager Elevation of Privilege Vulnerability Important
Windows Credential User Interface CVE-2026-96978 Windows Credential User Interface Elevation of Privilege Vulnerability Important
Windows Defender Firewall Service CVE-2026-112758 Windows Defender Firewall Service Elevation of Privilege Vulnerability Important
Windows Deployment Services CVE-2026-105558 Windows Deployment Services Remote Code Execution Vulnerability Important
Windows Deployment Services CVE-2026-112977 Windows Deployment Services Information Disclosure Vulnerability Important
Windows Deployment Services CVE-2026-119951 Windows Deployment Services Remote Code Execution Vulnerability Critical
Windows Deployment Services CVE-2026-118213 Windows Deployment Services Information Disclosure Vulnerability Important
Windows Deployment Services CVE-2026-113818 Windows Deployment Services Information Disclosure Vulnerability Important
Windows Device Association Service CVE-2026-119874 Windows Device Association Service Elevation of Privilege Vulnerability Important
Windows Device Association Service CVE-2026-112743 Windows Device Association Service Elevation of Privilege Vulnerability Important
Windows Device Association Service CVE-2026-119866 Windows Device Association Service Elevation of Privilege Vulnerability Important
Windows Device Association Service CVE-2026-119844 Windows Device Association Service Elevation of Privilege Vulnerability Important
Windows Device Inventory CVE-2026-113750 Windows Device Inventory Elevation of Privilege Vulnerability Important
Windows Devices Human Interface CVE-2026-113817 Windows Devices Human Interface Elevation of Privilege Vulnerability Important
Windows DHCP Client CVE-2026-96115 Windows DHCP Client Elevation of Privilege Vulnerability Important
Windows DHCP Client CVE-2026-88240 Windows DHCP Client Elevation of Privilege Vulnerability Important
Windows DHCP Client CVE-2026-113863 Windows DHCP Client Elevation of Privilege Vulnerability Important
Windows DHCP Client CVE-2026-118739 Windows DHCP Client Denial of Service Vulnerability Important
Windows DHCP Server CVE-2026-105560 Windows DHCP Server Remote Code Execution Vulnerability Important
Windows DHCP Server CVE-2026-72998 Windows DHCP Server Remote Code Execution Vulnerability Important
Windows DHCP Server CVE-2026-119890 Windows DHCP Server Denial of Service Vulnerability Important
Windows DHCP Server CVE-2026-96134 Windows DHCP Server Denial of Service Vulnerability Important
Windows DHCP Server CVE-2026-105588 Windows DHCP Server Elevation of Privilege Vulnerability Important
Windows DHCP Server CVE-2026-105557 Windows DHCP Server Information Disclosure Vulnerability Important
Windows DHCP Server CVE-2026-88216 Windows DHCP Server Remote Code Execution Vulnerability Important
Windows DHCP Server CVE-2026-88243 Windows DHCP Server Remote Code Execution Vulnerability Important
Windows DHCP Server CVE-2026-113773 Windows DHCP Server Spoofing Vulnerability Important
Windows Diagnostic Policy Service CVE-2026-112800 Windows Diagnostic Policy Service Elevation of Privilege Vulnerability Important
Windows Diagnostic Policy Service CVE-2026-95934 Windows Diagnostic Policy Service Elevation of Privilege Vulnerability Important
Windows Diagnostic Policy Service CVE-2026-95976 Windows Diagnostic Policy Service Elevation of Privilege Vulnerability Important
Windows DIAL Client CVE-2026-96076 Windows DIAL Client Elevation of Privilege Vulnerability Important
Windows DirectX CVE-2026-94507 DirectX Elevation of Privilege Vulnerability Important
Windows Distributed File System (DFS) CVE-2026-118142 Windows Distributed File System (DFS) Elevation of Privilege Vulnerability Important
Windows Distributed Transaction Coordinator CVE-2026-119919 Windows Distributed Transaction Coordinator Elevation of Privilege Vulnerability Important
Windows Distributed Transaction Coordinator CVE-2026-119917 Windows Distributed Transaction Coordinator Elevation of Privilege Vulnerability Important
Windows DNS CVE-2026-113855 Windows DNS Remote Code Execution Vulnerability Important
Windows DNS CVE-2026-96972 Windows DNS Server Information Disclosure Vulnerability Important
Windows DNS CVE-2026-105520 Windows DNS Elevation of Privilege Vulnerability Important
Windows DNS CVE-2026-96987 Windows DNS Information Disclosure Vulnerability Important
Windows DNS CVE-2026-96986 Windows DNS Information Disclosure Vulnerability Important
Windows DNS CVE-2026-96985 Windows DNS Information Disclosure Vulnerability Important
Windows DNS CVE-2026-88218 Windows DNS Remote Code Execution Vulnerability Important
Windows DNS CVE-2026-119905 Windows DNS Spoofing Vulnerability Important
Windows DNS CVE-2026-119971 Windows DNS Server Information Disclosure Vulnerability Important
Windows DNS CVE-2026-96176 Windows DNS Denial of Service Vulnerability Important
Windows DNS CVE-2026-96980 Windows DNS Information Disclosure Vulnerability Important
Windows DNS CVE-2026-96976 Windows DNS Information Disclosure Vulnerability Important
Windows DNS CVE-2026-96984 Windows DNS Information Disclosure Vulnerability Important
Windows DNS CVE-2026-119970 Windows DNS Information Disclosure Vulnerability Important
Windows DNS CVE-2026-96983 Windows DNS Denial of Service Vulnerability Important
Windows DNS CVE-2026-119953 Windows DNS Elevation of Privilege Vulnerability Important
Windows DNS CVE-2026-96970 Windows DNS Information Disclosure Vulnerability Important
Windows DNS CVE-2026-108425 Windows DNS Information Disclosure Vulnerability Important
Windows DNS CVE-2026-109463 Windows DNS Remote Code Execution Vulnerability Important
Windows DNS CVE-2026-96988 Windows DNS Information Disclosure Vulnerability Important
Windows DNS CVE-2026-105579 Windows DNS Information Disclosure Vulnerability Important
Windows DNS CVE-2026-97006 Windows DNS Information Disclosure Vulnerability Important
Windows DPAPI (Data Protection Application Programming Interface) CVE-2026-113763 Windows DPAPI (Data Protection Application Programming Interface) Elevation of Privilege Vulnerability Important
Windows DWM Core Library CVE-2026-105575 Windows DWM Core Library Elevation of Privilege Vulnerability Important
Windows DWM Core Library CVE-2026-112986 Windows DWM Core Library Elevation of Privilege Vulnerability Important
Windows DWM Core Library CVE-2026-105583 Windows DWM Core Library Elevation of Privilege Vulnerability Important
Windows DWM Core Library CVE-2026-105582 Windows DWM Core Library Elevation of Privilege Vulnerability Important
Windows Encrypting File System (EFS) CVE-2026-105527 Windows Encrypting File System (EFS) Denial of Service Vulnerability Important
Windows Encrypting File System (EFS) CVE-2026-96973 Windows Encrypting File System (EFS) Elevation of Privilege Vulnerability Important
Windows Enhanced Storage CVE-2026-119394 Windows Enhanced Storage Remote Code Execution Vulnerability Important
Windows Error Reporting CVE-2026-96153 Windows Error Reporting Elevation of Privilege Vulnerability Important
Windows Error Reporting CVE-2026-105540 Windows Error Reporting Elevation of Privilege Vulnerability Important
Windows Error Reporting CVE-2026-85862 Windows Error Reporting Elevation of Privilege Vulnerability Important
Windows Error Reporting CVE-2026-94525 Windows Error Reporting Elevation of Privilege Vulnerability Important
Windows Error Reporting CVE-2026-95947 Windows Error Reporting Elevation of Privilege Vulnerability Important
Windows eSCL Scanner CVE-2026-112801 Windows eSCL Scanner Elevation of Privilege Vulnerability Important
Windows eSCL Scanner CVE-2026-95956 Windows eSCL Scanner Remote Code Execution Vulnerability Important
Windows Event Collector Service CVE-2026-112793 Windows Event Collector Service Elevation of Privilege Vulnerability Important
Windows Event Collector Service CVE-2026-112796 Windows Event Collector Service Elevation of Privilege Vulnerability Important
Windows Event Logging Service CVE-2026-95997 Windows Event Logging Service Elevation of Privilege Vulnerability Important
Windows Event Viewer CVE-2026-95977 Windows Event Viewer Information Disclosure Vulnerability Important
Windows exFAT File System CVE-2026-112766 Windows exFAT File System Elevation of Privilege Vulnerability Important
Windows exFAT File System CVE-2026-112804 Windows exFAT File System Elevation of Privilege Vulnerability Important
Windows Failover Cluster CVE-2026-119869 Windows Failover Cluster Elevation of Privilege Vulnerability Important
Windows Fast FAT Driver CVE-2026-113751 Windows Fast FAT Driver Elevation of Privilege Vulnerability Important
Windows Feedback Hub CVE-2026-96075 Windows Feedback Hub Elevation of Privilege Vulnerability Important
Windows File Server Resource Management Service CVE-2026-108415 Windows File Server Resource Management Service Elevation of Privilege Vulnerability Important
Windows File Server Resource Management Service CVE-2026-108416 Windows File Server Resource Management Service Elevation of Privilege Vulnerability Important
Windows File Server Resource Management Service CVE-2026-108421 Windows File Server Resource Management Service Elevation of Privilege Vulnerability Important
Windows File Server Resource Management Service CVE-2026-113765 Windows File Server Resource Management Service Elevation of Privilege Vulnerability Important
Windows FileCrypt Driver CVE-2026-113754 Windows FileCrypt Driver Information Disclosure Vulnerability Important
Windows FileCrypt Driver CVE-2026-113757 Windows FileCrypt Driver Information Disclosure Vulnerability Important
Windows FileCrypt Driver CVE-2026-113756 Windows FileCrypt Driver Security Feature Bypass Vulnerability Important
Windows Filter Manager CVE-2026-113755 Windows Filter Manager Elevation of Privilege Vulnerability Important
Windows Filter Manager CVE-2026-121673 Windows Filter Manager Elevation of Privilege Vulnerability Important
Windows Filtering Platform (WFP) CVE-2026-88215 Windows Filtering Platform (WFP) Elevation of Privilege Vulnerability Important
Windows Filtering Platform (WFP) CVE-2026-112756 Windows Filtering Platform (WFP) Elevation of Privilege Vulnerability Important
Windows Filtering Platform (WFP) CVE-2026-105553 Windows Filtering Platform (WFP) Elevation of Privilege Vulnerability Important
Windows FTP Service CVE-2026-118137 Windows FTP Service Elevation of Privilege Vulnerability Important
Windows Function Discovery Resource Publication CVE-2026-125134 Windows Function Discovery Resource Publication Remote Code Execution Vulnerability Critical
Windows Function Discovery Resource Publication CVE-2026-119907 Windows Function Discovery Resource Publication Elevation of Privilege Vulnerability Important
Windows Function Discovery SSDP Provider CVE-2026-118145 Windows Function Discovery SSDP Provider Remote Code Execution Vulnerability Critical
Windows GDI CVE-2026-108407 Windows GDI Elevation of Privilege Vulnerability Important
Windows GDI CVE-2026-108424 Windows GDI Information Disclosure Vulnerability Important
Windows GDI CVE-2026-94527 Windows GDI Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-125137 Windows Graphics Kernel Elevation of Privilege Vulnerability Critical
Windows Graphics Kernel CVE-2026-96133 Windows Graphics Kernel Information Disclosure Vulnerability Important
Windows Graphics Kernel CVE-2026-95922 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95932 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95942 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-96137 Windows Graphics Kernel Information Disclosure Vulnerability Important
Windows Graphics Kernel CVE-2026-95938 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95935 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-96144 Windows Graphics Kernel Information Disclosure Vulnerability Important
Windows Graphics Kernel CVE-2026-96126 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95879 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95888 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-94519 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-119841 Windows Graphics Kernel Information Disclosure Vulnerability Important
Windows Graphics Kernel CVE-2026-96048 Windows Graphics Kernel Information Disclosure Vulnerability Important
Windows Graphics Kernel CVE-2026-95895 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-96122 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-96124 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95909 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95906 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-88217 Windows Graphics Kernel Information Disclosure Vulnerability Important
Windows Graphics Kernel CVE-2026-95946 Windows Graphics Kernel Information Disclosure Vulnerability Important
Windows Graphics Kernel CVE-2026-95971 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-96160 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95950 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-119966 Windows Graphics Kernel Elevation of Privilege Vulnerability Critical
Windows Graphics Kernel CVE-2026-96171 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-96168 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95966 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95953 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95948 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95974 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95991 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95983 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows Graphics Kernel CVE-2026-95973 Windows Graphics Kernel Elevation of Privilege Vulnerability Important
Windows HTTP.sys CVE-2026-95923 Windows HTTP.sys Elevation of Privilege Vulnerability Important
Windows HTTP.sys CVE-2026-119942 HTTP.sys Information Disclosure Vulnerability Important
Windows HTTP.sys CVE-2026-119992 Windows HTTP.sys Elevation of Privilege Vulnerability Important
Windows HTTP.sys CVE-2026-119946 HTTP.sys Information Disclosure Vulnerability Important
Windows Hyper-V CVE-2026-119391 Windows Hyper-V Elevation of Privilege Vulnerability Important
Windows Hyper-V CVE-2026-96965 Windows Hyper-V Denial of Service Vulnerability Important
Windows Hyper-V CVE-2026-113861 Windows Hyper-V Elevation of Privilege Vulnerability Critical
Windows Hyper-V CVE-2026-119960 Windows Hyper-V Elevation of Privilege Vulnerability Critical
Windows Hyper-V CVE-2026-119826 Windows Hyper-V Elevation of Privilege Vulnerability Important
Windows Hyper-V CVE-2026-113753 Windows Hyper-V Elevation of Privilege Vulnerability Critical
Windows Hyper-V CVE-2026-119385 Windows Hyper-V Denial of Service Vulnerability Important
Windows Hyper-V CVE-2026-113860 Windows Hyper-V Elevation of Privilege Vulnerability Critical
Windows Hyper-V CVE-2026-113856 Windows Hyper-V Elevation of Privilege Vulnerability Critical
Windows Hyper-V CVE-2026-113864 Windows Hyper-V Elevation of Privilege Vulnerability Critical
Windows Hyper-V CVE-2026-119947 Windows Hyper-V Elevation of Privilege Vulnerability Critical
Windows Hyper-V CVE-2026-119955 Windows Hyper-V Denial of Service Vulnerability Important
Windows Hyper-V CVE-2026-113865 Windows Hyper-V Elevation of Privilege Vulnerability Critical
Windows Hyper-V CVE-2026-95913 Windows Hyper-V Denial of Service Vulnerability Important
Windows Hyper-V CVE-2026-119959 Windows Hyper-V Spoofing Vulnerability Important
Windows Hyper-V CVE-2026-95910 Windows Hyper-V Security Feature Bypass Vulnerability Important
Windows IKE Extension CVE-2026-122169 Windows IKE Extension Spoofing Vulnerability Important
Windows Image Acquisition CVE-2026-122163 Windows Image Acquisition Remote Code Execution Vulnerability Important
Windows Imaging Component CVE-2026-96164 Windows Imaging Component Remote Code Execution Vulnerability Important
Windows Input System CVE-2026-119862 Windows Input System Elevation of Privilege Vulnerability Important
Windows Input System CVE-2026-119916 Windows Input System Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-105532 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96028 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-119838 Windows Installer Information Disclosure Vulnerability Important
Windows Installer CVE-2026-112789 Windows Installer Information Disclosure Vulnerability Important
Windows Installer CVE-2026-105545 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96062 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-119831 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-119865 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-119867 Windows Installer Security Feature Bypass Vulnerability Important
Windows Installer CVE-2026-119852 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96073 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96061 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-105543 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-119398 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96060 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-105501 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96047 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-105507 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96027 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96029 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-95951 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-113847 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96004 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-119929 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-119399 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96026 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96019 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-119887 Windows Installer Information Disclosure Vulnerability Important
Windows Installer CVE-2026-119892 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96046 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96152 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96008 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-119903 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96035 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96036 Windows Installer Elevation of Privilege Vulnerability Important
Windows Installer CVE-2026-96085 Windows Installer Elevation of Privilege Vulnerability Important
Windows Internet (wininet.dll) CVE-2026-96093 Windows Internet (wininet.dll) Information Disclosure Vulnerability Important
Windows Internet Connection Sharing (ICS) CVE-2026-119861 Windows Internet Connection Sharing (ICS) Elevation of Privilege Vulnerability Important
Windows Internet Connection Sharing (ICS) CVE-2026-118124 Windows Internet Connection Sharing (ICS) Elevation of Privilege Vulnerability Important
Windows Internet Connection Sharing (ICS) CVE-2026-119860 Windows Internet Connection Sharing (ICS) Elevation of Privilege Vulnerability Important
Windows Internet Connection Sharing (ICS) CVE-2026-122179 Windows Internet Connection Sharing (ICS) Elevation of Privilege Vulnerability Important
Windows Internet Connection Sharing (ICS) CVE-2026-119859 Windows Internet Connection Sharing (ICS) Elevation of Privilege Vulnerability Important
Windows Internet Information Services CVE-2026-119961 Windows Internet Information Services Remote Code Execution Vulnerability Critical
Windows Internet Information Services CVE-2026-119936 Windows Internet Information Services Denial of Service Vulnerability Important
Windows Internet Information Services CVE-2026-119909 Windows Internet Information Services Denial of Service Vulnerability Important
Windows Inventory Backup CVE-2026-105584 Windows Inventory Backup Information Disclosure Vulnerability Important
Windows IP Translation Configuration Service CVE-2026-119871 Windows IP Translation Configuration Service Elevation of Privilege Vulnerability Important
Windows iSCSI CVE-2026-88234 Windows iSCSI Remote Code Execution Vulnerability Important
Windows iSCSI CVE-2026-95898 Windows iSCSI Elevation of Privilege Vulnerability Important
Windows iSCSI CVE-2026-105518 Windows iSCSI Remote Code Execution Vulnerability Important
Windows iSCSI CVE-2026-88231 Windows iSCSI Information Disclosure Vulnerability Important
Windows iSCSI CVE-2026-122177 Windows iSCSI Elevation of Privilege Vulnerability Important
Windows iSCSI Target Service CVE-2026-83684 Windows iSCSI Target Service Information Disclosure Vulnerability Important
Windows Kerberos CVE-2026-85844 Windows Kerberos Elevation of Privilege Vulnerability Important
Windows Kerberos CVE-2026-96082 Windows Kerberos Denial of Service Vulnerability Important
Windows Kerberos CVE-2026-119940 Windows Kerberos Denial of Service Vulnerability Important
Windows Kerberos CVE-2026-70240 Windows Kerberos Denial of Service Vulnerability Important
Windows Kerberos CVE-2026-122164 Windows Kerberos Elevation of Privilege Vulnerability Important
Windows Kerberos CVE-2026-119847 Windows Kerberos Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-119918 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-105513 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-119868 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-105504 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-96031 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-112802 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-112805 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-95988 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-95905 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-105552 Windows Kernel Information Disclosure Vulnerability Important
Windows Kernel CVE-2026-119965 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-112973 Windows Kernel Security Feature Bypass Vulnerability Important
Windows Kernel CVE-2026-112969 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-105566 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-119935 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-119857 Windows Kernel Information Disclosure Vulnerability Important
Windows Kernel CVE-2026-96129 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-108403 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-114170 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-112790 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-119884 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-109473 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-94514 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-96052 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-96058 Windows Kernel Information Disclosure Vulnerability Important
Windows Kernel CVE-2026-119912 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-122183 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel CVE-2026-118143 Windows Kernel Elevation of Privilege Vulnerability Important
Windows Kernel-Mode Drivers CVE-2026-96139 Windows Kernel-Mode Drivers Elevation of Privilege Vulnerability Important
Windows Language Experience Service CVE-2026-113766 Windows Language Experience Service Tampering Vulnerability Important
Windows Layer-2 Bridge Network Driver CVE-2026-108402 Windows Layer-2 Bridge Network Driver Denial of Service Vulnerability Important
Windows LDAP - Lightweight Directory Access Protocol CVE-2026-119958 Windows LDAP - Lightweight Directory Access Protocol Remote Code Execution Vulnerability Critical
Windows Link Layer Topology Discovery Protocol CVE-2026-116706 Windows Link Layer Topology Discovery Protocol Remote Code Execution Vulnerability Important
Windows Link Layer Topology Discovery Protocol CVE-2026-116707 Windows Link Layer Topology Discovery Protocol Elevation of Privilege Vulnerability Important
Windows Link Layer Topology Discovery Protocol CVE-2026-88244 Windows Link Layer Topology Discovery Protocol Remote Code Execution Vulnerability Important
Windows Link-Layer Discovery Protocol (LLDP) CVE-2026-112975 Windows Link-Layer Discovery Protocol (LLDP) Denial of Service Vulnerability Important
Windows Link-Layer Discovery Protocol (LLDP) CVE-2026-113816 Windows Link-Layer Discovery Protocol (LLDP) Elevation of Privilege Vulnerability Important
Windows Local Security Authority Subsystem Service (LSASS) CVE-2026-88227 Windows Local Security Authority Subsystem Service (LSASS) Elevation of Privilege Vulnerability Important
Windows Local Security Authority Subsystem Service (LSASS) CVE-2026-96016 Windows Local Security Authority Subsystem Service (LSASS) Elevation of Privilege Vulnerability Important
Windows Local Security Authority Subsystem Service (LSASS) CVE-2026-96066 Windows Local Security Authority Subsystem Service (LSASS) Elevation of Privilege Vulnerability Important
Windows Local Security Authority Subsystem Service (LSASS) CVE-2026-70231 Windows Local Security Authority Subsystem Service (LSASS) Elevation of Privilege Vulnerability Important
Windows Local Security Authority Subsystem Service (LSASS) CVE-2026-88228 Windows Local Security Authority Subsystem Service (LSASS) Elevation of Privilege Vulnerability Important
Windows Local Security Authority Subsystem Service (LSASS) CVE-2026-85801 Windows Local Security Authority Subsystem Service (LSASS) Elevation of Privilege Vulnerability Important
Windows Local Session Manager (LSM) CVE-2026-95876 Windows Local Session Manager (LSM) Elevation of Privilege Vulnerability Important
Windows LUAFV CVE-2026-88230 Windows LUA File Virtualization Filter Driver Elevation of Privilege Vulnerability Important
Windows LUAFV CVE-2026-96117 Windows LUA File Virtualization Filter Driver Elevation of Privilege Vulnerability Important
Windows Management Instrumentation CVE-2026-105580 Windows Management Instrumentation Remote Code Execution Vulnerability Important
Windows Management Instrumentation CVE-2026-105546 Windows Management Instrumentation Elevation of Privilege Vulnerability Important
Windows Management Instrumentation CVE-2026-112965 Windows Management Instrumentation Information Disclosure Vulnerability Important
Windows Management Instrumentation CVE-2026-105503 Windows Management Instrumentation Elevation of Privilege Vulnerability Important
Windows Management Instrumentation CVE-2026-108410 Windows Management Instrumentation Information Disclosure Vulnerability Important
Windows Management Instrumentation CVE-2026-105524 Windows Management Instrumentation Elevation of Privilege Vulnerability Important
Windows Management Instrumentation CVE-2026-95920 Windows Management Instrumentation Elevation of Privilege Vulnerability Important
Windows Management Instrumentation CVE-2026-112814 Windows Management Instrumentation Elevation of Privilege Vulnerability Important
Windows Management Services CVE-2026-119836 Windows Management Services Information Disclosure Vulnerability Important
Windows Maps CVE-2026-122182 Windows Maps Elevation of Privilege Vulnerability Important
Windows Media Player CVE-2026-88229 Windows Media Player Remote Code Execution Vulnerability Important
Windows Message Queuing CVE-2026-118126 Windows Message Queuing Elevation of Privilege Vulnerability Important
Windows Message Queuing CVE-2026-119848 Windows Message Queuing Denial of Service Vulnerability Important
Windows Message Queuing CVE-2026-118125 Windows Message Queuing Elevation of Privilege Vulnerability Important
Windows Message Queuing CVE-2026-119833 Windows Message Queuing Elevation of Privilege Vulnerability Important
Windows Message Queuing CVE-2026-119963 Windows Message Queuing Remote Code Execution Vulnerability Critical
Windows Message Queuing CVE-2026-116710 Windows Message Queuing Remote Code Execution Vulnerability Critical
Windows Message Queuing CVE-2026-105515 Windows Message Queuing Denial of Service Vulnerability Important
Windows Message Queuing CVE-2026-119964 Windows Message Queuing Remote Code Execution Vulnerability Critical
Windows Message Queuing Queue Manager CVE-2026-109459 Windows Message Queuing Queue Manager Remote Code Execution Vulnerability Critical
Windows Message Queuing Queue Manager CVE-2026-119967 Windows Message Queuing Queue Manager Remote Code Execution Vulnerability Critical
Windows Microsoft Account Sign-in Assistant CVE-2026-119921 Windows Microsoft Account Sign-in Assistant Elevation of Privilege Vulnerability Important
Windows Microsoft Account Sign-in Assistant CVE-2026-119816 Windows Microsoft Account Sign-in Assistant Elevation of Privilege Vulnerability Important
Windows Microsoft DirectMusic CVE-2026-95901 Microsoft DirectMusic Remote Code Execution Vulnerability Important
Windows Microsoft DirectMusic CVE-2026-95896 Microsoft DirectMusic Remote Code Execution Vulnerability Important
Windows Microsoft DirectMusic CVE-2026-95891 Microsoft DirectMusic Remote Code Execution Vulnerability Important
Windows Microsoft DirectMusic CVE-2026-95882 Microsoft DirectMusic Remote Code Execution Vulnerability Important
Windows MIDI Service Module CVE-2026-105574 Windows MIDI Service Module Elevation of Privileges Vulnerability Important
Windows MIDI Service Module CVE-2026-105565 Windows MIDI Service Module Elevation of Privileges Vulnerability Important
Windows MIDI Service Module CVE-2026-119901 Windows MIDI Service Module Elevation of Privileges Vulnerability Important
Windows Mobile Device Management CVE-2026-119944 Windows Mobile Device Management Elevation of Privilege Vulnerability Important
Windows Modern Device Management (MDM) CVE-2026-113820 Windows Modern Device Management (MDM) Elevation of Privilege Vulnerability Important
Windows Modern Device Management (MDM) CVE-2026-102219 Windows Modern Device Management (MDM) Remote Code Execution Vulnerability Important
Windows Modern Device Management (MDM) CVE-2026-112987 Windows Modern Device Management (MDM) Elevation of Privilege Vulnerability Important
Windows Modern Device Management (MDM) CVE-2026-96184 Windows Modern Device Management (MDM) Elevation of Privilege Vulnerability Important
Windows Modern Device Management (MDM) CVE-2026-119945 Windows Modern Device Management (MDM) Remote Code Execution Vulnerability Important
Windows Multiple Provider Router CVE-2026-118220 Windows Multiple Provider Router Elevation of Privilege Vulnerability Important
Windows NetBIOS CVE-2026-105551 Windows NetBIOS Elevation of Privilege Vulnerability Important
Windows NetBIOS CVE-2026-96971 Windows NetBIOS Elevation of Privilege Vulnerability Important
Windows NetBIOS CVE-2026-112798 Windows NetBIOS Elevation of Privilege Vulnerability Important
Windows NetBIOS CVE-2026-119873 Windows NetBIOS Elevation of Privilege Vulnerability Important
Windows Network Address Translation (NAT) CVE-2026-113862 Windows Network Address Translation (NAT) Remote Code Execution Vulnerability Critical
Windows Network Address Translation (NAT) CVE-2026-88212 Windows Network Address Translation (NAT) Remote Code Execution Vulnerability Important
Windows Network Connected Devices Auto-Setup Service CVE-2026-125136 Windows Network Connected Devices Auto-Setup Service Remote Code Execution Vulnerability Critical
Windows Network Connection Broker CVE-2026-119821 Windows Network Connection Broker Elevation of Privilege Vulnerability Important
Windows Network Connection Broker CVE-2026-105525 Windows Network Connection Broker Elevation of Privilege Vulnerability Important
Windows Network Connection Broker CVE-2026-108406 Windows Network Connection Broker Elevation of Privilege Vulnerability Important
Windows Network File System CVE-2026-118736 Windows Network File System Information Disclosure Vulnerability Important
Windows NTFS CVE-2026-102200 Windows NTFS Tampering Vulnerability Important
Windows NTFS CVE-2026-105542 Windows NTFS Remote Code Execution Vulnerability Important
Windows NTFS CVE-2026-100223 Windows NTFS Elevation of Privilege Vulnerability Important
Windows NTFS CVE-2026-113848 Windows NTFS Remote Code Execution Vulnerability Important
Windows NTFS CVE-2026-119933 Windows NTFS Elevation of Privilege Vulnerability Important
Windows NTFS CVE-2026-119900 Windows NTFS Elevation of Privilege Vulnerability Important
Windows NTFS CVE-2026-113844 Windows NTFS Tampering Vulnerability Important
Windows NTLM CVE-2026-121680 Windows NTLM Spoofing Vulnerability Important
Windows ODBC Driver CVE-2026-108411 Microsoft ODBC Driver Remote Code Execution Vulnerability Important
Windows OLE CVE-2026-95933 Windows OLE Elevation of Privilege Vulnerability Important
Windows OLE CVE-2026-96110 Windows OLE Information Disclosure Vulnerability Important
Windows OLE DB CVE-2026-105587 Windows OLE DB Elevation of Privilege Vulnerability Important
Windows Overlay Filter CVE-2026-121670 Windows Overlay Filter Elevation of Privilege Vulnerability Important
Windows Overlay Filter CVE-2026-112750 Windows Overlay Filter Information Disclosure Vulnerability Important
Windows Overlay Filter CVE-2026-112813 Windows Overlay Filter Elevation of Privilege Vulnerability Important
Windows Overlay Filter CVE-2026-112760 Windows Overlay Filter Elevation of Privilege Vulnerability Important
Windows Overlay Filter CVE-2026-119822 Windows Overlay Filter Elevation of Privilege Vulnerability Important
Windows Overlay Filter CVE-2026-108409 Windows Overlay Filter Information Disclosure Vulnerability Important
Windows Partition Management Driver CVE-2026-105018 Windows Partition Management Driver Elevation of Privilege Vulnerability Important
Windows PCI Bus Driver CVE-2026-96981 Windows PCI Bus Driver Elevation of Privilege Vulnerability Important
Windows PCI Bus Driver CVE-2026-96992 Windows PCI Bus Driver Elevation of Privilege Vulnerability Important
Windows Performance Counters CVE-2026-88220 Windows Performance Counters Information Disclosure Vulnerability Important
Windows Performance Counters CVE-2026-95975 Windows Performance Counters Remote Code Execution Vulnerability Important
Windows Performance Counters CVE-2026-113768 Windows Performance Counters Remote Code Execution Vulnerability Important
Windows Performance Monitor CVE-2026-96993 Windows Performance Monitor Remote Code Execution Vulnerability Important
Windows Phone Service CVE-2026-96107 Windows Phone Service Elevation of Privilege Vulnerability Important
Windows Point-to-Point Protocol over Ethernet (PPPoE) CVE-2026-118123 Windows Point-to-Point Protocol over Ethernet (PPPoE) Elevation of Privilege Vulnerability Important
Windows Point-to-Point Protocol over Ethernet (PPPoE) CVE-2026-105511 Windows Point-to-Point Protocol over Ethernet (PPPoE) Elevation of Privilege Vulnerability Important
Windows PowerShell CVE-2026-124224 PowerShell Elevation of Privilege Vulnerability Important
Windows PowerShell CVE-2026-113815 Microsoft PowerShell Security Feature Bypass Vulnerability Important
Windows PowerShell CVE-2026-124226 Microsoft PowerShell Security Feature Bypass Vulnerability Important
Windows PowerShell CVE-2026-124225 Windows PowerShell Remote Code Execution Vulnerability Important
Windows Print Spooler Components CVE-2026-112806 Windows Print Spooler Components Information Disclosure Vulnerability Important
Windows Print Spooler Components CVE-2026-119939 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-105567 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-119950 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-105531 Windows Print Spooler Components Information Disclosure Vulnerability Important
Windows Print Spooler Components CVE-2026-119913 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-113770 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-112792 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-112980 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-112762 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-112765 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-112791 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-112976 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-113752 Windows Print Spooler Components Remote Code Execution Vulnerability Critical
Windows Print Spooler Components CVE-2026-112978 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-112797 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-112808 Windows Print Spooler Components Information Disclosure Vulnerability Important
Windows Print Spooler Components CVE-2026-112811 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-112981 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows Print Spooler Components CVE-2026-112752 Windows Print Spooler Components Elevation of Privilege Vulnerability Important
Windows PrintWorkflowUserSvc CVE-2026-119928 Windows PrintWorkflowUserSvc Elevation of Privilege Vulnerability Important
Windows PrintWorkflowUserSvc CVE-2026-119898 Windows PrintWorkflowUserSvc Elevation of Privilege Vulnerability Important
Windows Program Compatibility Assistant Service CVE-2026-88247 Windows Program Compatibility Assistant Service Information Disclosure Vulnerability Important
Windows Program Compatibility Assistant Service CVE-2026-123388 Windows Program Compatibility Assistant Service Elevation of Privilege Vulnerability Important
Windows Projected File System CVE-2026-112799 Windows Projected File System Elevation of Privilege Vulnerability Important
Windows Projected File System CVE-2026-113764 Windows Projected File System Information Disclosure Vulnerability Important
Windows Projected File System Filter Driver CVE-2026-108414 Windows Projected File System Filter Driver Elevation of Privilege Vulnerability Important
Windows Push Notification Core CVE-2026-96023 Windows Push Notification Core Elevation of Privilege Vulnerability Important
Windows Push Notifications CVE-2026-95881 Windows Push Notifications Elevation of Privilege Vulnerability Important
Windows Raw Image Extension CVE-2026-114169 Windows Raw Image Extension Remote Code Execution Vulnerability Critical
Windows Raw Image Extension CVE-2026-114166 Microsoft Raw Image Extension Information Disclosure Vulnerability Important
Windows Redirected Drive Buffering CVE-2026-108412 Windows Redirected Drive Buffering System Elevation of Privilege Vulnerability Important
Windows Redirected Drive Buffering CVE-2026-113772 Windows Redirected Drive Buffering Information Disclosure Vulnerability Important
Windows Remote Access API CVE-2026-119853 Remote Access API Elevation of Privilege Vulnerability Important
Windows Remote Access API CVE-2026-119396 Windows Remote Access API Tampering Vulnerability Important
Windows Remote Access Connection Manager CVE-2026-113843 Windows Remote Access Connection Manager Elevation of Privilege Vulnerability Important
Windows Remote Assistance CVE-2026-112751 Windows Remote Assistance Elevation of Privilege Vulnerability Important
Windows Remote Desktop CVE-2026-119932 Windows Remote Desktop Denial of Service Vulnerability Important
Windows Remote Desktop Services CVE-2026-119957 Windows Remote Desktop Services Elevation of Privilege Vulnerability Critical
Windows Remote Desktop Services CVE-2026-122166 Windows Remote Desktop Services Elevation of Privilege Vulnerability Important
Windows Remote Desktop Services CVE-2026-108401 Remote Desktop Services Remote Code Execution Vulnerability Important
Windows Remote Desktop Services CVE-2026-119882 Windows Remote Desktop Services Information Disclosure Vulnerability Important
Windows Remote Procedure Call CVE-2026-119972 Remote Procedure Call Denial of Service Vulnerability Important
Windows Remote Procedure Call Runtime CVE-2026-118737 Remote Procedure Call Runtime Remote Code Execution Vulnerability Critical
Windows Resilient File System (ReFS) CVE-2026-105509 Windows Resilient File System (ReFS) Elevation of Privilege Vulnerability Important
Windows Resilient File System (ReFS) CVE-2026-119386 Windows Resilient File System (ReFS) Elevation of Privilege Vulnerability Important
Windows Rich Text Edit Control CVE-2026-96081 Windows Rich Text Edit Control Remote Code Execution Vulnerability Important
Windows RNDIS CVE-2026-112755 Windows RNDIS Elevation of Privilege Vulnerability Important
Windows Sandbox CVE-2026-119906 Windows Sandbox Elevation of Privilege Vulnerability Important
Windows Schannel CVE-2026-119952 Windows Schannel Remote Code Execution Vulnerability Critical
Windows Secure Kernel Mode CVE-2026-112757 Windows Secure Kernel Mode Information Disclosure Vulnerability Important
Windows Secure Socket Tunneling Protocol (SSTP) CVE-2026-105561 Windows Secure Socket Tunneling Protocol (SSTP) Denial of Service Vulnerability Important
Windows Secure Socket Tunneling Protocol (SSTP) CVE-2026-105510 Windows Secure Socket Tunneling Protocol (SSTP) Elevation of Privilege Vulnerability Important
Windows Security Account Manager CVE-2026-112966 Windows Security Account Manager Denial of Service Vulnerability Important
Windows Security Account Manager CVE-2026-112795 Windows Security Account Manager Denial of Service Vulnerability Important
Windows Security Account Manager CVE-2026-122474 Windows Security Account Manager Remote Protocol Security Feature Bypass Vulnerability Important
Windows Security Center CVE-2026-113842 Windows Security Center Elevation of Privilege Vulnerability Important
Windows Sensor Data Service CVE-2026-88241 Windows Sensor Data Service Elevation of Privilege Vulnerability Important
Windows Server for NFS CVE-2026-118140 Server for NFS Information Disclosure Vulnerability Important
Windows Setup and Deployment CVE-2026-105547 Windows Setup and Deployment Elevation of Privilege Vulnerability Important
Windows Setup and Deployment CVE-2026-119914 Windows Setup and Deployment Elevation of Privilege Vulnerability Important
Windows Shell CVE-2026-105506 Windows Shell Information Disclosure Vulnerability Important
Windows Shell CVE-2026-97013 Windows Shell Elevation of Privilege Vulnerability Important
Windows Shell CVE-2026-102868 Windows Shell Information Disclosure Vulnerability Important
Windows Shell CVE-2026-119817 Windows Shell Elevation of Privilege Vulnerability Important
Windows Shell CVE-2026-119938 Windows Shell Remote Code Execution Vulnerability Important
Windows Smart Card CVE-2026-95968 Windows Smart Card Elevation of Privilege Vulnerability Important
Windows Smart Card CVE-2026-118144 Windows Smart Card Elevation of Privilege Vulnerability Important
Windows Smart Card CVE-2026-119383 Windows Smart Card Elevation of Privilege Vulnerability Important
Windows Smart Card CVE-2026-112794 Windows Smart Card Elevation of Privilege Vulnerability Important
Windows Smart Card CVE-2026-119835 Windows Smart Card Elevation of Privilege Vulnerability Important
Windows Smart Card CVE-2026-105549 Windows Smart Card Information Disclosure Vulnerability Important
Windows SMB CVE-2026-122176 Windows SMB Remote Code Execution Vulnerability Important
Windows SMB CVE-2026-119988 Windows SMB Remote Code Execution Vulnerability Important
Windows SMB Client CVE-2026-112971 Windows SMB Client Elevation of Privilege Vulnerability Important
Windows SMB Client CVE-2026-112812 Windows SMB Client Elevation of Privilege Vulnerability Important
Windows SMB Client CVE-2026-119870 Windows SMB Client Elevation of Privilege Vulnerability Important
Windows SMB Client CVE-2026-112970 Windows SMB Client Elevation of Privilege Vulnerability Important
Windows SMB Server CVE-2026-112972 Windows SMBv3 Server Remote Code Execution Vulnerability Important
Windows SMB Server Network Transport Driver (srvnet.sys) CVE-2026-113825 Windows SMB Server Network Transport Driver (srvnet.sys) Remote Code Execution Vulnerability Critical
Windows SSDP Service CVE-2026-85907 Windows Simple Search and Discovery Protocol (SSDP) Service Elevation of Privilege Vulnerability Important
Windows State Repository Service CVE-2026-112979 Windows State Repository Service Tampering Vulnerability Important
Windows StateRepository API CVE-2026-95998 Windows StateRepository API Tampering Vulnerability Important
Windows Storage CVE-2026-105534 Windows Storage Remote Code Execution Vulnerability Important
Windows Storage CVE-2026-105529 Windows Storage Elevation of Privilege Vulnerability Important
Windows Storage CVE-2026-95889 Windows Storage Elevation of Privilege Vulnerability Important
Windows Storage CVE-2026-119389 Windows Storage Elevation of Privilege Vulnerability Important
Windows Storage Spaces Controller CVE-2026-119851 Windows Storage Spaces Controller Elevation of Privilege Vulnerability Important
Windows Storage Spaces Controller CVE-2026-119392 Windows Storage Spaces Controller Elevation of Privilege Vulnerability Important
Windows Storage Spaces Controller CVE-2026-113814 Windows Storage Spaces Controller Remote Code Execution Vulnerability Important
Windows Storage Spaces Controller CVE-2026-105024 Windows Storage Spaces Controller Elevation of Privilege Vulnerability Important
Windows Storage Spaces Controller CVE-2026-122475 Windows Storage Spaces Controller Remote Code Execution Vulnerability Important
Windows Storage Spaces Controller CVE-2026-119908 Windows Storage Spaces Controller Remote Code Execution Vulnerability Important
Windows Storport Miniport Driver CVE-2026-119885 Windows Storport Miniport Driver Elevation of Privilege Vulnerability Important
Windows Storport Miniport Driver CVE-2026-119830 Windows Storport Miniport Driver Elevation of Privilege Vulnerability Important
Windows Storport Miniport Driver CVE-2026-119875 Windows Storport Miniport Driver Information Disclosure Vulnerability Important
Windows Storport Miniport Driver CVE-2026-119823 Windows Storport Miniport Driver Remote Code Execution Vulnerability Important
Windows Subsystem for Linux CVE-2026-119834 Windows Subsystem for Linux Elevation of Privilege Vulnerability Important
Windows Subsystem for Linux CVE-2026-119846 Windows Subsystem for Linux Elevation of Privilege Vulnerability Important
Windows Subsystem for Linux CVE-2026-88237 Windows Subsystem for Linux Elevation of Privilege Vulnerability Important
Windows System Events Broker CVE-2026-105530 Windows System Events Broker Information Disclosure Vulnerability Important
Windows Task Scheduler CVE-2026-95894 Windows Task Scheduler Elevation of Privilege Vulnerability Important
Windows Task Scheduler CVE-2026-96845 Windows Task Scheduler Elevation of Privilege Vulnerability Important
Windows Task Scheduler CVE-2026-122174 Windows Task Scheduler Elevation of Privilege Vulnerability Important
Windows Task Scheduler CVE-2026-112759 Windows Task Scheduler Elevation of Privilege Vulnerability Important
Windows Task Scheduler CVE-2026-88233 Windows Task Scheduler Elevation of Privilege Vulnerability Important
Windows Task Scheduler CVE-2026-96053 Windows Task Scheduler Elevation of Privilege Vulnerability Important
Windows TCP/IP CVE-2026-113859 Windows TCP/IP Remote Code Execution Vulnerability Critical
Windows TCP/IP CVE-2026-96077 Windows TCP/IP Denial of Service Vulnerability Important
Windows TCP/IP CVE-2026-96969 Windows TCP/IP Elevation of Privilege Vulnerability Important
Windows TCP/IP CVE-2026-96102 Windows TCP/IP Elevation of Privilege Vulnerability Important
Windows Telephony Service CVE-2026-116700 Windows Telephony Service Elevation of Privilege Vulnerability Important
Windows Telephony Service CVE-2026-108413 Windows Telephony Service Elevation of Privilege Vulnerability Important
Windows Telephony Service CVE-2026-108408 Windows Telephony Service Information Disclosure Vulnerability Important
Windows Telephony Service CVE-2026-119886 Windows Telephony Service Elevation of Privilege Vulnerability Important
Windows Text Services Framework CVE-2026-96022 Windows Text Services Framework Information Disclosure Vulnerability Important
Windows Text Services Framework CVE-2026-119925 Windows Text Services Framework Elevation of Privilege Vulnerability Important
Windows Text Services Framework CVE-2026-119818 Windows Text Services Framework Elevation of Privilege Vulnerability Important
Windows Text Services Framework CVE-2026-119931 Windows Text Services Framework Elevation of Privilege Vulnerability Important
Windows TPM CVE-2026-119382 Windows TPM Elevation of Privilege Vulnerability Critical
Windows Universal Disk Format File System Driver (UDFS) CVE-2026-119837 Windows Universal Disk Format File System Driver (UDFS) Elevation of Privilege Vulnerability Important
Windows Universal Disk Format File System Driver (UDFS) CVE-2026-122984 Windows Universal Disk Format File System Driver (UDFS) Elevation of Privilege Vulnerability Important
Windows Universal Disk Format File System Driver (UDFS) CVE-2026-119840 Windows Universal Disk Format File System Driver (UDFS) Elevation of Privilege Vulnerability Important
Windows Update Stack CVE-2026-122162 Windows Update Stack Information Disclosure Vulnerability Important
Windows USB Audio Class driver (usbaudio.sys) CVE-2026-119829 Windows USB Audio Class driver (usbaudio.sys) Elevation of Privilege Vulnerability Important
Windows USB Driver CVE-2026-95872 Windows USB Driver Elevation of Privilege Vulnerability Important
Windows USB Driver CVE-2026-96055 Windows USB Driver Elevation of Privilege Vulnerability Important
Windows USB Driver CVE-2026-119872 Windows USB Driver Elevation of Privilege Vulnerability Important
Windows USB Driver CVE-2026-96005 Windows USB Driver Elevation of Privilege Vulnerability Important
Windows USB Driver CVE-2026-96057 Windows USB Driver Elevation of Privilege Vulnerability Important
Windows USB Driver CVE-2026-112764 Windows USB Driver Elevation of Privilege Vulnerability Important
Windows USB Driver CVE-2026-96051 Windows USB Driver Elevation of Privilege Vulnerability Important
Windows USB Driver CVE-2026-122167 Windows USB Driver Elevation of Privilege Vulnerability Important
Windows USB Driver CVE-2026-96056 Windows USB Driver Elevation of Privilege Vulnerability Important
Windows USB Hub Driver CVE-2026-95999 Windows USB Hub Driver Elevation of Privilege Vulnerability Important
Windows USB Hub Driver CVE-2026-95902 Windows USB Hub Driver Elevation of Privilege Vulnerability Important
Windows USB Hub Driver CVE-2026-96041 Windows USB Hub Driver Information Disclosure Vulnerability Important
Windows USB Scanner Driver CVE-2026-119876 Windows USB Scanner Driver Elevation of Privilege Vulnerability Important
Windows USB Video Driver CVE-2026-112990 Windows USB Video Driver Elevation of Privilege Vulnerability Important
Windows USB Video Driver CVE-2026-95961 Windows USB Video Driver Elevation of Privilege Vulnerability Important
Windows USB Video Driver CVE-2026-112984 Windows USB Video Driver Elevation of Privilege Vulnerability Important
Windows USB Video Driver CVE-2026-95965 Windows USB Video Driver Elevation of Privilege Vulnerability Important
Windows User Manager Service CVE-2026-95987 Windows User Manager Service Elevation of Privilege Vulnerability Important
Windows User Manager Service CVE-2026-96037 Windows User Manager Service Elevation of Privilege Vulnerability Important
Windows USM Communication Manager CVE-2026-97000 Windows USM Communication Manager Elevation of Privilege Vulnerability Important
Windows Virtual Filtering Platform (VFP) CVE-2026-95962 Windows Virtual Filtering Platform (VFP) Remote Code Execution Vulnerability Important
Windows VMSwitch CVE-2026-97002 Microsoft Windows VMSwitch Elevation of Privilege Vulnerability Important
Windows Volume Shadow Copy CVE-2026-105017 Volume Shadow Copy Elevation of Privilege Vulnerability Important
Windows Volume Shadow Copy CVE-2026-119941 Volume Shadow Copy Elevation of Privilege Vulnerability Important
Windows Win32K CVE-2026-119827 Windows Win32k Elevation of Privilege Vulnerability Important
Windows Win32K CVE-2026-95893 Win32k Information Disclosure Vulnerability Important
Windows Win32K CVE-2026-119825 Win32k Information Disclosure Vulnerability Important
Windows Win32K CVE-2026-122170 Windows Win32k Elevation of Privilege Vulnerability Important
Windows Win32K CVE-2026-105028 Windows Win32k Elevation of Privilege Vulnerability Important
Windows Win32K CVE-2026-119856 Win32k Information Disclosure Vulnerability Important
Windows Win32K CVE-2026-119910 Win32k Information Disclosure Vulnerability Important
Windows Win32K CVE-2026-119899 Windows Win32k Elevation of Privilege Vulnerability Important
Windows WinHTTP CVE-2026-108423 Windows WinHTTP Information Disclosure Vulnerability Important
Windows Wireless Networking CVE-2026-105589 Windows Wireless Networking Elevation of Privilege Vulnerability Important
Windows WLAN Service CVE-2026-96086 Windows WLAN Service Denial of Service Vulnerability Important
Windows Xbox Live Networking Service CVE-2026-112967 Windows Xbox Live Networking Service Remote Code Execution Vulnerability Critical
Windows XWizard Framework CVE-2026-113760 Windows XWizard Framework Elevation of Privilege Vulnerability Important
Winlogon CVE-2026-83563 Winlogon Elevation of Privilege Vulnerability Important
Winlogon CVE-2026-105522 Winlogon Elevation of Privilege Vulnerability Important
Winsock CVE-2026-96994 Winsock Elevation of Privilege Vulnerability Important
Winsock CVE-2026-105526 Winsock Elevation of Privilege Vulnerability Important
Xbox CVE-2026-66801 Microsoft Xbox Remote Code Execution Vulnerability Important
Xbox CVE-2026-95874 Xbox Gaming Services Elevation of Privilege Vulnerability Important

Three new stable kernels for Tuesday

Linux Weekly News
lwn.net
2026-11-10 14:06:06
Greg Kroah-Hartman has released the 7.3.4, 6.18.63, and 6.12.117 stable kernels. The 7.3.4 kernel has more than 1,250 patches, 6.18.63 contains more than 860, and 6.12.117 includes more than 1,530 patches. Users of these kernels are, of course, encouraged to upgrade. ...
Original Article

[Posted November 10, 2026 by jzb]

Greg Kroah-Hartman has released the 7.3.4 , 6.18.63 , and 6.12.117 stable kernels. The 7.3.4 kernel has more than 1,250 patches, 6.18.63 contains more than 860, and 6.12.117 includes more than 1,530 patches. Users of these kernels are, of course, encouraged to upgrade.


A comprehensive study of how fingerprintable users are

Hacker News
fingerprinting.study
2026-11-10 14:03:54
Comments...
Original Article

Tom Ritter 1 , Fatih Kilic 2 , Frederik Braun 1 , Elisa Luo 3 , Geoffrey M. Voelker 3 , Stefan Savage 3 , Christoph Kerschbaumer 1

1 Mozilla Corporation  · 2 University of Toronto  · 3 UC San Diego

This is the companion site to a study Mozilla ran on browser fingerprinting. With the help of almost 25 million Firefox release users, we measured how identifiable browsers really are, found which characteristics make them unique, and used that to design the fingerprinting protections that shipped in Firefox 143. Here you can read the paper and its key findings, browse the full appendix data the PDF had no room for, download the privacy-preserving aggregate data and analysis code, learn how the data was collected, and run an interactive test that compares your own browser against the measured population. If you have a question the data could answer, there is also a discussion board for proposing follow-up research.

Browser fingerprinting is a known tracking mechanism on the modern web, but its real-world effectiveness toward users has been hard to measure. To build robust protections, we measured uniqueness across a large, unbiased population, to determined what individual metrics cause users to be unique. These measurements used multiple privacy preserving technologies, like OHTTP , to ensure that no individual users can be identified or tracked across the web. The protections we built into Firefox avoid web compatibility problems while dropping the percentage of uniquely identifiable users from 75% to 46%.

Line chart. The share of users with a unique fingerprint falls as each of the protections Firefox 143 shipped is added, for three modeled fingerprinters. Fingerprint Pro falls from 75.7% to 46.8%, Signifyd from 60.9% to 38.5%, and Akamai from 18.2% to 9.0%.
Shows the percentage of users seen as unique by three commercial fingerprinters. Each step adds one protection on top of all the ones before it, weighted across the four operating systems.

Paper abstract

Web browser fingerprinting has become a key tracking mechanism on the modern web, yet its real-world effectiveness and which of the existing mitigations offer value at scale remain insufficiently understood.

In this paper, we present a large-scale study of browser fingerprinting based on real-world telemetry from almost 25 million Firefox release users. This dataset enables us to quantify user uniqueness at population scale and identify which characteristics contribute most to this uniqueness.

Our analysis shows fingerprintability is largely driven by a small set of high-impact characteristics and their combinations, rather than the accumulation of many independent measurements. Building on these insights, we propose and evaluate fingerprinting protections based on their impact on uniqueness and cohort structure, and design data-driven mitigations.

These protections, shipped in Firefox 143, reduce the fraction of uniquely identifiable users from 75% to 46% while maintaining web compatibility, demonstrating that practical reductions in fingerprintability are achievable in a mainstream browser.

Our key findings

Here's what we want to present to you with this paper and the broader scope of our work.

Uniqueness is caused by a small number of metrics - not one or thirty

Fingerprinting test sites have a seemingly endless list of measurements they can pull from your browser. If a user has a unique fingerprint, it is typically not because of a single measurement, but it is also not because of 20 or 30 measurements. It is a small number of metrics that make users unique .

In fact, it's very close to the 80/20 rule . Specifically, of all the users seen as unique by Fingerprint Pro (the most discerning fingerprinter we model) - 80% of them are unique after only 8 metrics - while the fingerprinter collects a total of over 50 metrics. Signifyd collects more metrics, but identifies fewer users as unique: 80% of the users it sees as unique will be identified after 9 metrics despite collecting over 80.

The numbers only mean anything per operating system

Whenever someone cites a single percentage when describing "How many users are unique" - you should be suspicious. Because this collapses multiple different populations that behave very differently .

Firstly, as a baseline, your operating system is always going to be exposed to a fingerprinter. We are always working within the constraint of web compatibility, and lying about the user's operating system breaks shortcut keys and gives you the wrong downloads among other problems. So if we know the website is going to learn your real OS anyway, we can use it to segment the population and analyze it separately.

And when you do you see that each operating system behaves differently because they have different important metrics. Admittedly, it's very difficult to give a concise summary of work and also provide four sets of numbers - so even we fall prey to the trap of providing a single number, as we did in the prior paragraph. But every time we have a single percentage, somewhere we have that number broken down by operating system, and in doing so, you will see that each behaves differently.

Entropy is not the measurement you want

It's so, so easy to take all the results for a metric and just calculate Shannon entropy - it's a standard yardstick in this literature. But as we show - a high Shannon entropy does not reliably predict fingerprinting impact .

Cohort size, not just uniqueness

Previous analyses calculated how many people were unique, but they did not analyze the other people - the ones who weren't. All those other people might be 1 million users who share one fingerprint or 500,000 distinct fingerprints shared by 2 people each - that's quite the difference.

We use the Simpson Index (aka the Herfindahl–Hirschman Index ) to quantify that difference and compare different sets of cohorts (shared fingerprints). This lets us compare how effective different fingerprinting defenses are based not just on how much uniqueness they eliminate but how much they collapse groups of users into each other.

For example, two different protections can each lower the share of unique users by about 2.1 percentage points. But one improves the cohort score by 56%, while another raises it by only 13%. Judged on uniqueness alone, two defenses can look equally effective; while the cohort improvement varies significantly.

The same protection performs very differently per platform

Protections are not uniformly impactful, and the variation is not small. As an example, clamping the available screen resolution takes 25.3 percentage points off cumulative macOS uniqueness but between 0 and 3 points off the other three platforms. Averaged across all users, that 25-point drop shrinks to 3.5 - a protection that matters enormously to one platform can look marginal in the aggregate .

This is yet another reason why it's so important to segment and analyze data on a per-operating-system basis.

Standardization and randomization go hand-in-hand

Making users report the same values makes them look more alike, but it never makes everyone look the same. Some users will still stand out, and that gets worse on websites with small visitor populations. Standardization improves the situation, but it should still be paired with randomization. Randomization is very strong when it works, but can always be detected and bypassed. Neither can carry the burden of providing privacy on its own.

The data shows why values differ, not just that they do

Correlating fingerprinting values with users' hardware and other characteristics let us identify why certain measurements differed between users. Knowing the root cause lets us build protections that reach much further, and protect small groups of users who would otherwise stand out as a minority.

Addressing these differences has already produced more consistent outputs for image rendering , Web Audio , and mathematical operations on Android, with more root causes being investigated.

Users don't connect website breakage to the setting

Breakage from a strict mode is delayed, and the delay hides the cause. Turning on a stricter mode is a one-time act - but the broken website arrives later and nothing connects the two. From the user's perspective, this website doesn't work in Firefox and they have no idea why and are frustrated. Report after report we see people posting for help, confused - despite having taken specific action to enable a hidden setting opting them into strict fingerprinting protections.

Protections that ship have to keep the web working

Users don't realize that a setting they changed caused the breakage, and don't know how to fix it - so a protection that breaks the web breaks the browser along with it. We selected and tuned mitigations on both measured impact and compatibility. For a default, compatibility isn't a trade-off against privacy - it's a precondition for it.

The hard part is finding what breaks

The web is vast, and even the most innocuous change is likely to break something somewhere. Some breakage can be anticipated, which helps design, testing, and detection. The other breakage gets fixed only if a chain of luck holds: someone has to recognize the breakage, report it, reproduce it on the right hardware, and get it to the right person.

We are deliberately not publishing everything we could

Commercial fingerprinters evolve continuously, and they borrow openly from the community that studies them. Sites built to teach people about fingerprinting - CreepJS among them - get picked up and used outright by fingerprinting products.

So we have been deliberately conservative. There are analyses this dataset would support that we have not run, data we could have released that we have not, and offensive angles on this work that we have not pursued. That is a choice rather than an oversight: we would rather leave a question open than make it easier to build a better fingerprinter .

Test your own browser

This interactive test re-implements individual measurements as close as possible to how Firefox's own collection code performed them, runs in your browser, and compares each result against the published aggregate data. For every characteristic you can see your value and how many of the ~25 million measured browsers share it - overall and within your operating system.

The test runs entirely in your browser. All comparisons happen locally, against our static reference files. No data is stored or submitted to us.

If the test, or anything else on this site, looks wrong, please report it as an issue on GitHub . For a problem with the test, include the diagnostics from its Copy diagnostics button, or, if you would rather not post your measured values publicly, email them to tom@ritter.vg .

Paper

The extended version of the paper is available as a PDF.

Full appendix data

The paper's appendices contain a wealth of data locked behind a reasonable page limit and PDF formatting. This full data page carries all of it - every rank for every operating system and all three modeled services, the complete protection chains, and the paper's figures regenerated at print resolution.

Data collection

Our measurements come from Firefox telemetry, specifically the user-characteristics ping, a dedicated telemetry ping. Unlike normal telemetry pings that are sent regularly, this ping must be explicitly enabled (which has happened twice, once in 2025 and once in 2026), and sends one data report before becoming dormant again.

This ping carries no client ID, only a UUID unique to the ping used to de-duplicate users. It cannot be keyed to any other telemetry submissions. It is submitted over Oblivious HTTP (OHTTP): a relay operated independently of Mozilla forwards the encrypted submission, so the relay can see the sender's IP address but not the contents, and Mozilla receives the contents but not the IP address. Access to the collected data was restricted to four authorized Mozilla employees. The data was retained for 90 days and has since been deleted.

Aggregate data & analysis code

We release four types of data:

  1. A list of fingerprints generated for different phases of protections, per modeled fingerprinter, with the user's OS and locale unmasked.
  2. Aggregate tables of the frequency of value per metric, split by OS
  3. Aggregate tables of the frequency of value per metric, correlated by other metrics' values, again split by OS
  4. A detailed analysis of rendered canvas images that allows comparison

In the fingerprint lists, the fingerprints cannot be recreated from a website measuring user characteristics, due to the way the telemetry was collected. After being generated, the files were shuffled to a new ordering, and any locale occurring fewer than 100 times was anonymized.

In the aggregate tables, any value observed fewer than 100 times within a single per-OS population is withheld - so the published data describes cohorts, never individuals.

In the canvas comparison, raw canvas renderings are provided, but they are devoid of any connection to other user data. Any unique canvas rendering is not provided; only the hash.

For verification and exploration, the code used to process the data and perform different analyses is available for review. It additionally contains the specific fingerprinting scripts captured, reverse engineered, and modeled for the paper.

Future Research

Far more can be asked of this dataset than we have asked. Some of it we chose not to pursue, some of it we simply did not think of, and some of it is a better fit for someone who is not us.

There is a discussion board for proposing follow-up analyses. Two kinds are worth posting:

  • Answerable from the published aggregate data. Anyone can run these - the per-operating-system distributions are released, and the analysis toolkit is open. Post the question anyway, so the work is not duplicated and so the result lands somewhere others can find it.
  • Needs the raw data. These we would have to run ourselves, since the underlying ping data is not something we can ever release. Describe what you want to know and why! To be clear, we do not have the raw data anymore but it is possible we will perform a re-collection in the future which we could analyze. We cannot promise to run everything, and some questions we will decline because we do not wish to help build a better fingerprinter.

Debunking Pete Hegseth’s Bullshit Impeachment Defense

Intercept
theintercept.com
2026-11-10 13:47:26
Fighting for his job before an impeachment vote, the flailing war secretary claimed “victory” in Iran. We checked his claims. The post Debunking Pete Hegseth’s Bullshit Impeachment Defense appeared first on The Intercept....
Original Article

On the eve of a House impeachment vote, self-styled Secretary of War Pete Hegseth made a rare appearance before the Pentagon press corps. Over half an hour, he declared every military operation he has overseen “lawful” and claims of civilian harm “slander.” He said the Iran war was a great victory and only 18 Americans have died in the conflict. He also claimed that the effort to impeach him was a stunt by just “one disgruntled congressman.”

None of it is true.

Rep. Thomas Massie, R-Ky., introduced articles of impeachment on the House floor Monday afternoon, charging Hegseth with “high crimes and misdemeanors.” Democrats are overwhelmingly expected to join Massie’s effort following their midterm election landslide. “I am a hard yes on the Hegseth resolution,” said Rep. Hakeem Jeffries of New York, the presumed next House speaker.

Massie wrote on X that if his impeachment resolution advances Tuesday evening, he will request a separate vote on each of the eight articles. “I’ve heard from several members they agree with some of the Articles of Impeachment but not all of them,” Massie wrote. “If the motion to kill my resolution by referring it to committee fails, and we proceed to the Articles themselves, I’ll request a vote on each of the Articles separately.”

As Hegseth steels himself for a vote that could see him put on trial in the Senate and sink his chances of serving for the rest of Trump’s term, The Intercept is dissecting his self-defense and examining Hegseth’s false claims about his disastrous war-making.

Everything Was “Lawful” and “Notified to Congress”

“Iran, the cartels, Maduro, Yemen — every one was a lawful operation ordered by the commander-in-chief, then ordered by myself, notified to Congress, and executed by American warriors who did their jobs.”

Experts in the laws of war , a Pentagon official , and members of Congress from both parties say Hegseth’s boat strikes against “cartels,” which have now killed upward of 240 people, are illegal extrajudicial killings. The military is not permitted to deliberately target civilians — even suspected criminals — who do not pose an imminent threat of violence.

Sarah Harrison, who previously advised Pentagon policymakers on issues related to human rights and the law of war, said that the attack on Venezuela was also a clear violation of international law and that the administration’s justifications for the raid were baseless.

Of the Iran war, Air Force Lt. Col. Rachel VanLandingham, a former chief of international law at U.S. Central Command, said the opening strike “ clearly violates the U.S. Constitution and the War Powers Resolution ,” which requires the president to seek congressional approval to start a war in most cases. Harrison Mann, a former U.S. Army officer and intelligence official and now the associate director for campaigns and policy at Win Without War, drew specific attention to the attacks on the bridges and water reservoirs in Iran. It is “quite dangerous to be conditioning the U.S. military to carry out orders that are clearly war crimes,” he warned .

Hegseth’s claims about notifications are also spurious. Congress never authorized the Iran war, and a call to the congressional “Gang of Eight” the night before is not the formal report experts say the law requires. Following the January attack on Venezuela, Republicans privately complained they were not told in advance.

“The Terrorists That We Hunt”

“As to the claim that the American military targets civilians, well, that is a lie and that is a slander against every professional who flew, sailed, and fought on these missions. The only people who target civilians are the terrorists that we hunt.”

The U.S. boat strike campaign has only targeted civilians . The summary executions of more than 240 people are a significant departure from standard practice in the long-running U.S. war on drugs , in which law enforcement agencies detained suspected drug smugglers and brought them to trial on criminal charges.

A U.S. military investigation also found U.S. forces attacked an elementary school in Minab, Iran, killing more than 150 people, most of them children. One official called it “colossal negligence.”

For months, Central Command has failed to answer questions about additional civilian casualties, including eight members of a family — the youngest, a 20-day-old infant — killed in an attack documented in an Intercept investigation.

These attacks came after Hegseth conducted a comprehensive campaign to undermine efforts to prevent and mitigate civilian harm. The Pentagon’s Civilian Protection Center of Excellence, for example, slashed its staff from 40 personnel in January 2025 to just nine by the end of the year, according to the report.

“Dead Where They Should Be ”

“More than 70 narco vessels sunk. 218 narco-terrorists dead where they should be. Maritime smuggling down at least 65 percent and dropping even further.”

Hegseth misstates the toll of his own boat strike campaign. The Intercept’s tracker counts 72 strikes and at least 243 dead. Sen. Tim Kaine, D-Va., after reviewing classified material, wrote that the evidence suggests the military killed people not involved in drug trafficking. A top Pentagon Joint Staff official told lawmakers in a classified briefing that victims of human trafficking could be among the dead of the first strike.

The drug claims fare no better. Deputy Assistant Secretary of War for Americas Security Affairs Joseph Humire, for example, offered completely different numbers to Congress, telling the House Armed Services Committee in March that there “has been a 20 percent reduction of movements of drug vessels in the Caribbean and an additional 25 percent reduction in the Eastern Pacific.”

The Pentagon’s latest civilian casualty report , meanwhile, claims no civilians were killed in the boat strikes. One U.S. official said it had “absolutely no credibility.”

Iran Was a “Historic Military Victory”

“By every measure, we achieved a historic military victory. Under 40 days of sustained combat…”

The Iran war, by all objective measures, is an abject failure. The conflict undermined the decades-old U.S. security framework, as well as America’s archipelago of bases, in the Middle East. Iran determined how to overwhelm U.S. air defenses , offering up a playbook for U.S. adversaries around the world. This, in turn, damaged U.S. military security across the globe. From Jordan to Kuwait to the United Kingdom, U.S. outposts are now increasingly vulnerable to attack . As a result, the Iran war has left the military on the brink of a “ breakdown .”

The Trump administration’s attempt to rebrand its faltering forever war hasn’t slowed the mounting toll of U.S. casualties, either. While Hegseth focused on the conflict’s first 40 days, the U.S. has suffered more casualties as a result of the conflict since the war formally ended and, in July, underwent a name change to “Overseas Operations.”

Voters did not see a victory either: About 6 in 10 told The Associated Press the war was the wrong decision , and Vice President JD Vance agreed , writing of the GOP’s crushing defeat in last week’s midterms: “The reason we lost is the war.”

18 Americans

“Eighteen Americans have given their lives in Operation Epic Fury.”

Hegseth spent his rare press conference using the troops under his leadership as a shield, claiming that indictments of him were actually indictments of them. When not using them for cover, Hegseth praised them. “They are the best of our nation. Like the president, I will defend them with every fiber of my being every single day,” he crowed.

What he didn’t care enough to do was offer an accurate count of the war’s toll. The official Pentagon count of deaths during Epic Fury is 15, not 18 — but that’s misdirection at best and a lie at worst. At least 23 military personnel have died in Operation Epic Fury and “Overseas Operations,” the new moniker for the war introduced in July, according to the Pentagon’s official count. (This includes 11 killed by hostile fire.) The actual number of troop deaths in the region since the war began is higher.

“One Disgruntled Congressman”

“This is one disgruntled guy who drew up some really flimsy articles.”

In Hegseth’s telling, Massie is pursuing his impeachment out of resentment over the loss of his Kentucky congressional seat to Trump-backed far-right candidate Ed Gallrein, a former Navy SEAL. But Massie’s impeachment effort has strong bipartisan support. The entire House Democratic caucus is widely expected to vote in favor of the impeachment effort. While no House Republicans aside from Massie have openly committed to voting yes, the outgoing congressman said Monday that he believes “several” Republicans will vote for the measure.

Republican Texas Sen. Ted Cruz agreed . So did Rep. Yassamin Ansari, D-Ariz., one of the leading voices for Hegseth’s impeachment. “I think there’s a high chance that it will be successful,” she told The Intercept of Massie’s effort. In April, Ansari filed six articles of impeachment against Hegseth, including violations of the law of armed conflict and targeting of civilians, abuse of power, and obstructing congressional oversight.

Discontent with Hegseth is widespread within the military establishment as well. The Intercept recently spoke with six current and former defense officials who said Hegseth had undermined the rule of law; irreparably harmed the U.S. military through purges of top commanders; spurred religious extremism ; and diminished the department he leads due to an almost endless raft of scandals and culture-war clownishness. In fact, 64 percent of active-duty service members, veterans, and military families disapprove of Hegseth, according to a recent poll conducted by Common Defense, a grassroots veterans organization.

The American people, writ large, appear to agree with Ansari, Massie, the U.S. officials, and those in the military’s orbit. Just 32 percent of voters approve of the way Hegseth is handling his job, while 57 percent disapprove, according to a Quinnipiac University poll in September.

Thoughts on AI Coding

Lobsters
danielbmarkham.com
2026-11-10 13:27:33
This is a commentary on the future of programming as a job. It is written by someone who grew up alongside the rise of personal computers. Comments...
Original Article

It occurs to me that while programming is going to be the first job mostly replaced by AI, most programmers have such a poor understanding of what the actual job is that we’re going to have problems figuring out what the job is going to morph into for those of us still coding.

I’m not worried as much about Computer Science, or at least the pure theoretical part. Those guys are rare, and since they’re interested in how programming works, my feeling is that they’ve still got a lot left to do. My concern is for the practitioner, the person assigned to do something with computers that the customer can’t. It used to be that this “something” was anything involving instructing computers to do useful things. The new definition is that it’s the same as it used to be, but these things also have to be things the customer has tried on their own and couldn’t make work. In any situation I can imagine, this will involve a lot of pre-generated LLM code to show the previous struggles.

Does that mean that the New Programmer is going to have the legacy system from hell to maintain and update? Maybe. I suppose that’s where a lot of the work is going to start. My guess is also that we’ll see a humongous amount of competition and bullshit from people claiming that “Your problem is that you haven’t tried my magical model/sauce/recipe yet”

Long term, however, my mind is that we’re going to need to separate intent from execution. We did this back in the old structured programming and early coding days, but it’s fallen out of fashion. We also never did that good of a job at it, we never agreed on what made good work, and there were so many tools and practices that the actual value was lost in the noise.

What is intent and how is it different from execution? Intent is a flowchart, roughly. I want these things done in this general pattern. (It’s not an actual flowchart. I’m using the simplest example I can think of. If only it were so easy!) Execution is making that general shape of things happen to the degree that the person making the flowchart is happy with the result.

The person making the flowchart never thinks in the appropriate amount of detail for execution to happen automatically. There are maybe millions of common error patterns, however, and LLMs kick but at finding error patterns and applying solution patterns. This is why we’re not all still drawing flowcharts. It’s also why it all looks like magic.

My analysis goes on from there but yeah, I do think there’s a piece missing and I think programmers will have a job in the future, at least the really good ones. This does raise an interesting question, though: can models be so deep that virtually every error pattern humans make with expressing intent can be covered?

We’re already working on that. Let’s have the computer interview us before it writes code. Let’s have on model quality check another. (See my earlier post.) I’m amazed that we suddenly have so many experts online with so many seasoned opinions about LLM coding, something that’s really still coming into existence. Some of the advice is useful. Most people, however, that you read as part of a large public audience are people who in some fashion desire to speak to a large public audience. It’s about their motivations and how much people like/respect them. It has nothing to do with actual value.

There is value, and there is a way forward. Like always, however, there’s a lot of hype and noise that we’re going to have to sift through in order to find a useful signal.

Starlink Mini 2

Hacker News
starlink.com
2026-11-10 13:22:32
Comments...
Original Article

Arizona Town’s Probe on Sex Abuse Claims Could Block Prison Firm Building New ICE Camp

Intercept
theintercept.com
2026-11-10 13:02:25
Following a LOOKOUT and Intercept investigation, town officials asked the private prison firm for information about a state prison it operated at the site. The post Arizona Town’s Probe on Sex Abuse Claims Could Block Prison Firm Building New ICE Camp appeared first on The Intercept....
Original Article

This story was published in partnership with LOOKOUT News .

An official from Marana, Arizona, is seeking clarification from the private prison giant Management and Training Corporation about its handling of sexual abuse allegations at the former state prison in the town, following an investigation from LOOKOUT and The Intercept.

In an October 28 letter, reviewed by LOOKOUT and The Intercept, Marana Finance Director and License Inspector Yiannis Kalaitzidis asked MTC Senior Vice President Mary Calvin for a written explanation of what the town official called an “apparent inconsistency” between state records and the facility’s 2023 Prison Rape Elimination Act, or PREA, audit, a report required by the federal law.

MTC ran a former state prison in Marana, Arizona, and plans to reopen it as an ICE detention camp.

The request is part of the town’s review of MTC’s October 1 application for a business license to “Operate Marana Detention Facility.” The company ran a former Arizona state prison in Marana and plans to reopen it imminently as a U.S. Immigration and Customs Enforcement detention camp.

The letter cites a September 29 LOOKOUT and Intercept investigation about how state records reference three allegations of sexual misconduct at the prison in 2022 and 2023.

PREA audits — which are required for jails, prisons, and detention centers at least once every three years — must record all allegations of sexual misconduct at detention facilities, whether they are substantiated or not. Certified in December 2023, MTC’s report for the Marana prison, however, recorded none.

Kalaitzidis noted in his letter that the audit says the finding of zero incidents was verified by the warden, chief of security, PREA compliance manager, and internal investigator. He also wrote that, despite the apparent reviews by several company officials, the report “does not appear to be certified or signed by any MTC personnel.”

The letter says the town of Marana is requesting the explanation as part of an investigation into whether MTC “made a material false statement in conducting the business” of the state prison facility, which would be grounds for denial of a business license according to the town’s code.

“The Town of Marana is currently reviewing MTC’s business license application,” said Andrea De La Cruz, the assistant town manager, told LOOKOUT and The Intercept by email. “As part of our review process and due diligence, the Town has contacted MTC to request additional information. The application remains under review, and no final determination has been made at this time.”

MTC did not respond to multiple requests for comment.

Changing Political Context

Local residents and officials say the state, the federal government, and MTC left them out of meaningful discussions about reopening the prison as an ICE camp, LOOKOUT and The Intercept previously reported.

For now, a town business license is among the few levers local officials have.

In an October 2 letter from the local group Pima Resists ICE, or PRICE, to a Marana official who specialized in licensure, organizers cited not only the discrepancies between state investigations into sexual abuse and the PREA audit, but also alleged violations involving an escape from an MTC prison in Kingman, Arizona, in 2010, as well as abuses in a New Mexico immigration camp run by MTC as revealed in a 2017 DHS Office of Inspector General report .

The inquiry comes as Arizona’s political landscape is shifting. The midterm election gave Democrats control of both chambers of the state legislature as well as the governor’s office — a historic change in state power. Republicans will be in the minority at the state Capitol for the first time in 60 years.

That has Democratic lawmakers talking about taking on one of the most contentious laws in recent Arizona history. Following protests across the state, Democrats took up the cause of repealing a controversial 2010 anti-immigrant law known as Senate Bill 1070. In 2012, the U.S. Supreme Court struck down three of its provisions, leaving a requirement that police check the immigration status of people they stop under certain circumstances.

“I would absolutely love to see a repeal of SB1070,” state Sen. Analise Ortiz, a Democrat from Glendale, told LOOKOUT and The Intercept. “There are still parts of that law on the books that are enabling cities to collaborate with ICE to rip families apart, and that needs to stop.”

State Rep. Betty Villegas, D-Tucson, echoed Ortiz: “We already have bills aligned to focus on what other states have done to control ICE from coming into private property.”

Following the lead of neighboring New Mexico’s prohibition on local jurisdictions entering into contracts with ICE for immigrant detention camps, Villegas said Democrats in Arizona see an appetite for doing something similar in their own state.

“We do not want the Democrats to wait until things get bad to investigate conditions.”

Ortiz agreed, saying there is “likely an appetite” for something similar in Arizona, and that the Latino Caucus would address the issue.

Local nonprofits said lawmakers should also conduct a review of no-bid contracts like the one inked between the Department of Homeland Security, ICE’s parent agency, and MTC.

“This was literally handed to them with no review and no public input,” said Caroline Isaacs, the executive director of Just Communities Arizona, a nonprofit working on criminal justice reform. “We do not want the Democrats to wait until things get bad to investigate conditions.”

“We want them to do this now, before people get hurt.”

How about ACORN to Stop the Budget Bill Cutbacks?

OrganizingUp
convergencemag.com
2026-11-10 13:00:59
Featured illustration: Kimmie Dearest Photo credit: Justin Kaneps for the All in Frame Collection Over the last year, more than 5 million people lost SNAP benefits–often called food stamps–across the United States at an accelerated pace that the Congressional Budget Office had not expected until 203...
Original Article

CiviCRM 6.20 Release

CiviCRM
civicrm.org
2026-11-08 12:55:36
Thanks to the hard work of CiviCRM’s incredible community of contributors, CiviCRM version 6.20.0 is now ready to download. This is a regular monthly release that includes new features and bug fixes. Details are available in the monthly release notes. Your are encouraged to upgrade now ...
Original Article

Thanks to the hard work of CiviCRM’s incredible community of contributors, CiviCRM version 6.20.0 is now ready to download. This is a regular monthly release that includes new features and bug fixes. Details are available in the monthly release notes .

Your are encouraged to upgrade now for the most stable, secure CiviCRM experience:

Download CiviCRM

Users of the CiviCRM Extended Security Releases (ESR) do not need to upgrade. The current version of ESR is CiviCRM 6.16.x (supported until April 2027).

Support CiviCRM

CiviCRM is community driven and is sustained through code contributions and generous financial support.

We are committed to keeping CiviCRM free and open, forever . We depend on your support to help make that happen. Please consider supporting CiviCRM today .

Big thanks to all our partners , members , ESR subscribers and contributors who give regularly to support CiviCRM for everyone.

Credits

AGH Strategies - Alice Frumin, Chris Garaffa; Agileware Pty Ltd - Justin Freeman; alilinares; Artful Robot - Rich Lott; Australian Greens - John Twyman; beatrizpaula03; Benjamin W; BrightMinded Ltd - Bradley Taylor; Christian Wach; civico GmbH - Johannes Filter; CiviCoop - Klaas Eikelboom; CiviCRM - Coleman Watts, Tim Otten; CiviDesk - Yashodha Chaku; civiservice.de - Martin Correll; CompuCo - Muhammad Shahrukh; Coop SymbioTIC - Mathieu Lutfy, Shane Bill; CSES (Chelmsford Science and Engineering Society) - Adam Wood; Dave D; Francesc Bassas i Bullich; Freeform Solutions - Herb van den Dool; Fuzion - Luke Stewart; GESTAD - Guillaume Sorel; Gray Digital - Richard Baugh; Greenpeace Central and Eastern Europe - Patrick Figel; Hans Rossel; Humanists UK - Andrew West; Jakub Fidler; JMA Consulting - Monish Deb, Seamus Lee; joapta-tech; Joinery - Allen Shaw; Juan Ignacio Sartor; kaustubh-compuco; Kevin Goess; knottheory; Megaphone Technology Consulting - Jon Goldberg; MJW Consulting - Matthew Wire, Jade Gaunt; NIAB - Stuart; Nicol Wistreich; OPEN - dewy; Progressive Technology Project - Jamie McClelland; Responsive Development Technologies - Thomas Nilefalk; Richard van Oosterhout; Robin Bowes; Sigtechnica; Sinjinsmiley; Skvare - Mark Hanna, Sunil Pawar; Squiffle Consulting - Aidan Saunders; Stiftung Pfadfinden - Andreas Lietz; Survos - Tac Tacelosky; SYSTOPIA - Dominic Tubach; Sylvain Plante; Tadpole Collective - Kevin Cristiano; Third Sector Design - William Mortada, Kurund Jalmi; Wikimedia Foundation - Eileen McNaughton, Lars Sander-Green; Youth Apostles Institute - John Volk

New Extensions

  • Mosaic Plus - The versafix-1 mosaico template is quite narrow, a maximum of 600px. For most screens, a width of 660px is quite reasonable and a better use of the screen.
  • Association Cockpit - Vereinsabfrage - Provides a simple, friendly screen for volunteers in small associations to find and edit contacts, add notes and see upcoming birthdays.
  • Create Household From Individuals - In SearchKits on Individuals, provide an action to create a new household with the Individuals as members.
  • CiviCoop Theme - Provides a custom branded stream and modern styling for CiviCRM using the RiverLea theme framework.

Windows 11 KB5132061 & KB5131087 cumulative updates released

Bleeping Computer
www.bleepingcomputer.com
2026-11-10 13:33:26
Microsoft has released the Patch Tuesday Windows 11 and cumulative updates for versions 26H2/25H2/24H2 and 23H2 to fix security vulnerabilities and bugs, and add new features. [...]...
Original Article
  • November 10, 2026
  • 01:33 PM

Windows 11

Microsoft has released the Patch Tuesday Windows 11 KB513261 and KB5131087 cumulative updates for versions 26H2/25H2/24H2 and 23H2 to fix security vulnerabilities and bugs and add new features.

Today's updates are mandatory as they contain the November 2026 Patch Tuesday security patches for hundreds of vulnerabilities discovered in previous months.

You can install today's update by going to Start > Settings > Windows Update and clicking on 'Check for Updates .'

image

You can also manually download and install the update from the Microsoft Update Catalog .

This is the eleventh 'Patch Tuesday' release in 2026, and it's based on 24H2, which means 25H2 or 26H2 get the same update. There are no exclusive or special changes. You'll get the same fixes across the two versions of Windows 11.

What's new in the November 2026 Patch Tuesday update

With today's update, Microsoft is adding new customization options to Windows 11 and fixing minor issues with File Explorer.

Here's the full list of improvements and fixes:

  • [Context menu in File Explorer]

    • New! This update introduces an updated context menu that is faster, simpler, and more customizable. The updated menu opens more quickly, reduces clutter, and gives you more control over the commands and app extensions that appear when you right-click.
      • You can now customize the context menu to better fit how you use Windows. Select Customize menu at the bottom of the context menu to open its Settings page.
        • Turn built-in Windows commands, such as Send to and Create shortcut , on or off.
        • Add commands such as Print to the context menu.
        • Choose which app extensions appear in the main menu or a submenu or hide the app extensions submenu.
        • Display Cut , Copy , Paste , Rename , Delete , and Share directly in the menu instead of as a row of icons.
        • Move Properties to the bottom of the context menu.
      • To personalize the context menu, right-click and select Customize menu , then choose the commands, app extensions, and layout you prefer. No action is required to use the default configuration. To see more options, hold down Shift and right-click on your desktop.

  • [Modernized AutoPlay experience]

    • New! This update modernizes the AutoPlay dialog that appears when you connect devices such as a phone, camera, or removable drive to your PC. The updated experience supports dark mode, responds better to text scaling and display settings, and makes AutoPlay notifications available in notification center for easier access.

  • [File Explorer]

    • New! Key file information, such as name, location, and date, now appear in a consistent layout on the File Explorer search results page, making search results easier to scan.
    • New! Address bar now supports ~ , making it quicker to navigate directly to your user profile folder and subfolders (for example, ~\AppData ).
    • New! This update enables dark mode support in the Folder Options dialog in File Explorer.

  • [XBOX mode]

    • New! This update introduces a refreshed Gaming Task View experience in XBOX mode, featuring a new navigation bar that provides quick access to Exit to Desktop and Power Options, making key system actions easier to access while gaming. 1

  • [Settings]

    • New! This update improves the Privacy & security page in Windows Settings by grouping related Camera, Microphone, and Location privacy controls and elevating usage information from linked pages onto the main page.
    • New! The Device Info card on the Settings Home page, first introduced in the March 2026 preview update KB5079391 , is expanding to additional markets. Available to users signed in with a Microsoft account, the card provides a quick view of key PC specifications and usage, with more detailed device information available under Settings > System > About . 1
    • This update makes some small visual refinements to the design of the temporary files section under Settings > System > Storage .

  • [Phone Link]

    • New! You can now hover over a recent message or notification in the Recent section to preview its content directly in Start without opening the item. This experience can be managed under Phone Link > Settings > Start menu personalization .

  • [Taskbar]

    • New! The update improves animations of app window previews when mousing across app icons in the taskbar.
    • This update improves the underlying state persistence of taskbar settings related to multiple monitors across monitor connections and disconnections.

  • [Magnifier]

    • New! Magnifier now includes a contrast theme toggle that can reduce screen glare while keeping the original colors in photos, videos, and charts. The toggle applies a dark contrast theme by default and is available from the Magnifier toolbar. To choose a different contrast theme, go to Settings > Accessibility > Magnifier . Color inversion remains available as a separate option.
    • New! Magnifier now supports per-monitor zoom, allowing each display to use its own zoom level while keeping the magnified view within that display. To use per-monitor zoom, set your displays to Extend under Settings > System > Display .
      • To adjust a display, move your pointer to it and press Windows key + Plus (+) or Windows key + Minus (-) , use Ctrl + Alt with the mouse wheel or move the Magnifier toolbar to that display and use its controls.
      • Per-monitor zoom is on by default. You can turn it off or adjust individual zoom levels from the Magnifier toolbar or under Settings > Accessibility > Magnifier .
    • New! Magnifier now supports viewport locking for multi-monitor setups with per-monitor zoom turned on. It keeps the magnified view on a display in place while you move the pointer to another display. The locked display remains interactive. Point to a display and press Ctrl + Windows key + K to lock or unlock its view.
      • Press Windows key + Esc to release all locked displays.
      • You can change the lock shortcut to Ctrl + Alt + P under Settings > Accessibility > Magnifier .

  • [Live Captions]

    • New! This update improves Live Captions with a new Include screen reader audio setting, which is off by default. With the setting off, Live Captions will not transcribe audio from screen readers such as Narrator, JAWS, and NVDA, keeping captions focused on microphone and system audio. To turn on this setting, go to Settings > Accessibility > Captions .

  • [Narrator]

    • New! Narrator now supports reading and navigating math equations in supported Microsoft 365 apps, including Word and PowerPoint, and supported web content in Microsoft Edge (version 153.0.4234.32 and later) and Google Chrome (version 153.0.8010.18 and later). This makes it easier for users who are blind or have low vision to understand and explore equations, formulas, and scientific notation.
      • Press Narrator key + Alt + N to turn on math navigation and use the arrow keys to explore parts of an equation. Press Esc to exit.
      • Math reading supports English (United States), English (United Kingdom), Traditional Chinese, Finnish, German, and Spanish. You can change the language and other math reading preferences in Narrator settings ( Accessibility > Narrator > Math reading ).

  • [Family Safety]

    • New! The update improves family safety messaging when applications are blocked because of age-restricted parental controls.

  • [Recovery]

    • New! This update enables Windows recovery (WinRE) to automatically reuse eligible Wi-Fi profiles already saved in Windows, including supported certificate-based networks. Devices can now get online automatically during recovery scenarios such as quick machine recovery or cloud rebuild, without preconfiguring Wi-Fi credentials in WinRE. This capability is on by default, and IT admins can disable it. This feature was previously disclosed last month and is now beginning to roll out.
    • To learn more, see Networking in WinRE .

  • [Cloud rebuild]

    • New! This update introduces Cloud rebuild, a new recovery option that reinstalls Windows 11 using a Windows image and device drivers downloaded from Windows Update, including when Windows is unable to start. No USB media or custom image is required. Cloud rebuild includes:
      • Drive sanitization: Choose to remove your files or securely erase data using the storage hardware’s erase capability before Windows is reinstalled. Sanitization is irreversible.
      • Remote management: IT administrators can configure and start a Cloud rebuild remotely through the Recovery CSP using either the currently installed build or a specified target build.
    • To start Cloud rebuild:
      • In Windows, go to Settings > System > Recovery , and then select Rebuild PC . The device restarts into the Windows Recovery Environment and starts Cloud rebuild.
      • Alternatively, if Windows can't start, the device enters the Windows Recovery Environment automatically after repeated boot failures. From the Windows Recovery Environment (WinRE), select Troubleshoot > Recovery and uninstall > Cloud rebuild .
      • Connect to a wired Ethernet or Wi-Fi network.
      • Review the target Windows build, edition, and language, and then confirm the data loss warning before the rebuild begins. You can choose whether to remove files or remove and sanitize files prior to Windows reinstalling.
    • To learn more, see Cloud rebuild .

  • [Windows settings backup and restore]

    • New! This update introduces a Restore Summary that appears after you restore a backup profile to a new device. The summary gives a clear overview of what was successfully restored, including Windows settings and the list of Microsoft Store apps. This improves transparency during device transitions and helps you validate your restore results and continue setup on your new device with confidence.
    • For more information see, Windows settings backup and restore overview .

  • [Adaptive hibernate policy]

    • New! This update improves the adaptive hibernate policy to provide more instant-on resumes from Modern Standby while helping preserve battery life when the charge is low. Noticeable changes include less hibernation while the battery is above 80% and hibernating sooner when the battery is below 10%.

  • [Security]

    • New! This update expands memory integrity protection across eligible devices. Supported PCs may now have memory integrity (HVCI) enabled during updates to help improve security and prepare devices for advanced Windows security features, while respecting existing user or IT administrator choices. For more information, see Expanding memory integrity protection across Windows devices .

  • [Windows IPv6 networking support]

    • New! Windows now supports IPv6 CLAT for Wi-Fi and Ethernet network interfaces, adding client-side 464XLAT translation so IPv4-only applications can continue reaching IPv4 services from IPv6-only networks. This helps organizations advance IPv6-only deployments while preserving compatibility for legacy IPv4 application scenarios.
      • Prefix discovery: PREF64 is discovered through Router Advertisements (RA) by default, with DNS ipv4only.arpa available as a fallback.
      • Requirements: CLAT requires SLAAC-based IPv6 addressing. DHCPv6 Prefix Delegation and Windows Subsystem for Linux (WSL) are not currently supported.
      • Configuration: Enable CLAT by using netsh interface clat set global permit=enabled pref64fromdns=enabled pref64fromra=enabled or Group Policy under Network > TCPIP Settings > IPv6 Transition Technologies .

  • [Data Protection API (DPAPI)]

    • New! This update adds a warning before prompt-based protect and unprotect operations. The warning explains that this prompt-based experience will be retired in April 2027. If you or an app use these prompts, stop creating new prompt-protected data, use a supported non-interactive protection flow, and decrypt or migrate existing prompt-protected data before retirement. DPAPI operations that do not use the prompt-based flow aren't affected. For more details, see CRYPTPROTECT_PROMPTSTRUCT structure (dpapi.h) .

  • [Windows Spotlight]

    • This update makes underlying platform changes to generally improve Windows Spotlight reliability on the lock screen.

  • [Unicode]

    • This update provides Windows text shaping support for Unicode 17.0, helping Windows correctly display and shape newly encoded characters and scripts. Unicode 17.0 added 4,803 characters, including support for four newly encoded scripts: Beria Erfe, Sidetic, Tai Yo, and Tolong Siki. These updates help keep Windows text support current as the Unicode Standard evolves and improve support for languages and writing systems used by people around the world.

Microsoft is not aware of any new issues with this month's Patch Tuesday, and it also patched a long-standing issue that broke USB audio on some PCs.

article image

Uncover email threats your existing defenses may miss.

Adaptive Security's AI agents analyze email intent, context, and behavior to uncover phishing, business email compromise, and invoice fraud.

See what's getting through with a 14-day read-only scan of Microsoft 365 or Google Workspace, with no MX changes.

Start your free email security scan.

Mayank Parmar

Mayank Parmar is an technology entrepreneur who is currently pursuing an MBA. At BleepingComputer, he covers technology news with a strong focus on Microsoft and Windows-related stories. He is always poking under the hood of Windows, looking for the latest secrets to reveal.

You may also like:

Work at the Frontier: AI's effect on freelance work

Hacker News
openai.com
2026-11-10 13:02:54
Comments...
Original Article

Show HN: Get your coding agent off ~2019 JavaScript, onto modern web primitives

Hacker News
github.com
2026-11-10 13:01:15
Comments...
Original Article

Modern Web Guidance Logo

Modern Web Guidance is a set of skills that embed web platform expertise, best practices, and browser compatibility data directly into your coding agents. It helps to steer your coding agents away from legacy patterns, and instead toward solutions that harness the power and capabilities of the modern web platform.

Stewarded by the Google Chrome, Microsoft Edge, Mozilla Firefox, and MDN teams, alongside the web development community.

Documentation · Eval Dashboard · Source Code · Report an Issue

Quickstart 

npx modern-web-guidance@latest install

This command runs an interactive wizard to install Modern Web Guidance. See Alternative Installation Methods below.

Try it out (without installing) 

# Search for relevant guides
npx modern-web-guidance@latest search "animate a dialog modal backdrop"

# Retrieve a guide by ID
npx modern-web-guidance@latest retrieve "animate-to-from-top-layer"

# Scan a codebase for legacy patterns to modernize
npx modern-web-guidance@latest legacy-scan .

Why?

Coding agents often default to older patterns because LLM training data contains vast amounts of legacy code. This often leads them to generate bloated JavaScript for tasks that now have native, high-performance web platform solutions.

Even if a model knows an API exists, it often lacks the density of real-world, modern implementation patterns required for production-ready code.

Modern Web Guidance bridges this gap. Our skill's CLI returns targeted, expert-curated guidelines directly into your agent's context window, focusing on:

  • Modern Browser APIs : Helping models correctly structure APIs they frequently misuse.
  • Performance & Accessibility : Preferring platform-level APIs that can be optimized by the browser and include built-in accessibility affordances.
  • Responsible Fallbacks : Guiding models to use sensible, lightweight fallbacks instead of heavy polyfills or legacy libraries.

What's Included?

We cover the past several years of the web platform's new features, all the way up to the cutting edge. The guides are designed to be token-efficient ; we run evals enabling us to prune lowest-common-denominator content that models already know.

Core Disciplines

🎨 User Experience

Smooth visual states (View Transitions, entry/exit animations, parallax scroll, CSS scrollbar-color ).

📐 CSS Layout

Modern layout systems (container queries, subgrid , modern color spaces like oklch , text-wrap tuning, and line-height trimming).

⚡ Performance

Speed optimizations (instant preloading, Interaction to Next Paint (INP) diagnostics, and scheduling tasks via scheduler.yield ).

📝 Forms & UI

Native components (Anchor Positioning for tooltips, Popover API, dialogs, :user-invalid validation, and auto-sizing fields).

♿ Accessibility

Important considerations (screen reader and keyboard operability, content navigation and discoverability).

🤖 Built-in AI

Local client models (native translation, summarization, and language detection APIs).

View an example: the navigation-drawer guide .

The full list

250 modern web features

CSS & Layout (140 features)

::backdrop content-visibility progress()
::details-content contrast-color() reading-flow
::file-selector-button Cross-document view transitions Relative colors
::placeholder currentColor rem
::selection Custom highlights resize (CSS property)
:dir() Custom properties revert
:focus-visible display animation revert-rule
:focus-within Element-scoped view transitions Safe area inset environment variables
:has() em unit Scroll marker target pseudo-classes
:host-context() field-sizing Scroll method promises
:is() filter Scroll snap
:modal flex-wrap: balance Scroll snap events
:not() Flexbox scroll-axis-lock
:nth-child() of <selector> font-size scroll-behavior
:placeholder-shown font-size-adjust Scroll-driven animations
:user-valid and :user-invalid Forced colors scroll-initial-target
:where() Gradient interpolation scroll-target-group
@function Gradients scrollbar-color
@scope Grid scrollbar-gutter
@starting-style Grid lanes scrollbar-width
@supports Hyphenation scrollend
abs() and sign() image-set() scrollIntoView()
accent-color Individual transform properties Shadow parts
Active view transition inherit sibling-count() and sibling-index()
Alt text for generated content initial Sticky positioning
Anchor position container queries Interaction media queries Subgrid
Anchor positioning interpolate-size System colors
Animations (CSS) isolation Text overflow
appearance Lab and LCH Text stroke and fill (compatibility prefixes)
aspect-ratio light-dark() text-box
at-rule() line-clamp text-decoration
attr() line-height text-decoration-skip-ink
background-blend-mode linear() easing text-decoration-skip-ink: all
background-clip: border-area Logical properties text-decoration-skip-spaces
border-radius Masks text-wrap
box-shadow min(), max(), and clamp() text-wrap: balance
calc-size() mix-blend-mode text-wrap: pretty
Cascade layers Nesting transition-behavior
ch unit Oklab and OkLCh Transitions (CSS)
clip-path overflow-clip-margin Trigonometric functions (CSS)
color-mix() overflow-wrap unset
color-scheme overflow: clip user-select
Conic gradients overlay View transitions
Container queries (size) overscroll-behavior view-transition-class
Container scroll-state queries prefers-color-scheme media query Viewport units
Container style queries prefers-contrast media query Web animations
Content prefers-reduced-motion media query

HTML & DOM (36 features)

:autofill <slot> HTML streaming setters
:indeterminate <video> HTML-in-canvas
<audio> Autonomous custom elements inert
<details> blocking="render" Interest invokers
<dialog closedby> Customizable <select> Invoker commands
<dialog> Declarative shadow DOM Lazy-loading media
<input type="checkbox" switch> Email, telephone, and URL <input> types moveBefore()
<input type="range"> Fetch priority MutationObserver
<input> focusgroup Mutually exclusive <details> elements
<link rel="expect"> Form-associated custom elements Popover
<link rel="preload"> hidden="until-found" popover="hint"
<progress> HTML setter methods Shadow DOM

JavaScript & APIs (74 features)

<install> integrity() for url() Sanitizer API
<meta name="text-scale"> Interaction contentful paint performance entries Scheduler API
<template for> Intersection observer Small, large, and dynamic viewport units
AbortController and AbortSignal Intl.DurationFormat Soft navigation performance entries
ARIA attribute reflection Keyboard events Speculation rules
ariaNotify() Language detector Subresource integrity
Async clipboard LanguageModel Summarizer
autocorrect Lazy-loading images and iframes SVG
beforeinstallprompt light-dark() image values Temporal
border-shape Local network access text-decoration-inset
Connection allowlists Long animation frames performance entries text-fit
corner-shape long-animation-frames-style-layout Top-level await
Credential management Navigation API touch-action
cross-origin() for url() navigator.install() Translator
document.modelContext Origin Trusted types
email-verification Page visibility User agent client hints
enterkeyhint Page visibility state performance entries Web app manifest
Event timing performance entries Partitioned cookies Web app origin migration
Federated credential management Password credentials Web authentication
Fetch Permissions policy Web authentication signal methods
fetchLater Pointer Events Web Cryptography
Form-associated WebMCP attributes Referrer policy WebAssembly
HTML processing instructions referrer-policy() for url() webcrypto-modern-algos
image() Registered custom properties WebOTP
inputmode Resize observer
203 real-world developer use cases

accessibility

  • accessible-error-announcement : Synchronize programmatic accessibility states (like aria-invalid) with the visual :user-invalid state to ensure screen reader users receive error feedback only after interaction, mirroring the visual experience.
  • accessible-generated-content : Use CSS generated content ( ::before / ::after ) in ways that stay accessible, including alternative text for decorative content.
  • respect-os-text-scale : Respect the operating system's text scale preference for a page so font sizes, layout, and rem-based measurements follow the user's accessibility settings.

built-in-ai

  • language-detection : Detect the language of user-generated content or already present site content.
  • language-model : Run on-device natural language inference in the browser using the Prompt API, with streaming output, structured JSON responses, and multi-turn session management.
  • summarizer : Summarize text content using the on-device Summarizer API.
  • translator : Translate text between languages using the on-device Translator API.

css

  • animate-to-intrinsic-sizes : Smoothly animate interactive components (like accordions, menus, and expanding cards) to and from their natural dimensions.
  • atrule-support-conditionals : Conditionally apply certain CSS rules or declarations only if a certain at-rule is supported by the browser.
  • calculate-with-intrinsic-sizes : Calculate the size of an element based on its intrinsic size, while ensuring it fits within given design constraints.
  • child-state-based-styling : Build a component that changes its styling based on the state of one of its child elements. For example, a component that renders in light or dark mode based on whether a theme toggle is checked (or not).
  • content-based-styling : Build a component that changes its layout based on whether it contains specific child elements (or not). For example, if the component contains an image, use a multi-column layout, otherwise default to a single-column layout.
  • css : Action-oriented guidelines for modern CSS architecture, including the cascade, selectors, scoping, nesting, and design tokens. Use this guide when authoring styles or managing design systems.
  • css-layout : Modern CSS layouts such as flexbox, grid, subgrid, container queries, anchor positioning, and intrinsic sizing. Use this skill when architecting responsive UI components or page layouts.
  • design-token-reactivity : Define higher-order design tokens, like density modes (compact, comfortable, spacious) or themes and have descendant components react to changes directly and in component-appropriate ways.
  • dynamic-sibling-styling : Create dynamic visual spectrums or layout arrangements that automatically adapt to the number of elements in a group.
  • fluid-scaling : Scale items like font size, spacing, and media sizes smoothly based on the parent container's size rather than using fixed breakpoints
  • individual-transform-properties : Animate or override individual CSS transform properties (e.g. translate, rotate, scale) independently of other transform properties on a single element.
  • overflow-clipping-control : Adjust the visible clipping boundary of an element to align with the content edge, padding edge, or border edge—or a specified offset from any of these—offering finer-grained control over how content is clipped.
  • reduce-style-repetition : Reduce excessive style repetition by encapsulating complex or dynamic styling logic into reusable functions (such as a function that computes a gradient based on a set of input parameters).
  • responsive-design : Build UI that adapts to container and viewport size, including container queries, dynamic viewport units, aspect ratios, and responsive typography.
  • selector-atrule-combinations : Target elements based on the intersection or union of selectors and conditional @-rules while minimizing repetition.
  • size-aware-styling : Build a component whose styles can be conditionally dependent on its own width or height, rather than the width or height of the viewport. For example a card component that can change its layouts depending on how large it is, or a call-to-action button that can conditionally display helper text based on its width.
  • style-parent-with-has : Style parent elements of a form field (e.g. labels or fieldsets) when the field is invalid.
  • usage-aware-component-variations : Build components that adapt visual logic based on semantic context using CSS container style queries.

forms

  • animated-select-picker : Create a custom select component whose dropdown is animated. For example, the menu fades or slides into view, or the options animate upon selection.
  • autofill-address-form : Build an address form with correct autocomplete attributes and autofill support.
  • autofill-highlight-inputs : Customize the styling of form fields that have been autofilled and not edited by the user
  • autofill-payment-form : Build a payment form that collects card details with correct autocomplete values and autofill support.
  • autofill-sign-in-form : Build a sign-in form with correct autocomplete values and autofill support.
  • autofill-sign-up-form : Build a sign-up form with correct autocomplete values and autofill support.
  • brand-consistent-forms : Match checkboxes, radio buttons, range sliders, and progress bars to your site's color palette without replacing them with custom components.
  • branded-select-styling : Create custom select elements whose button, picker, arrow icon, and checkmark all seamlessly match your brand or design system's typography, colors, spacing, and border treatments.
  • custom-select-picker-layouts : Create custom select pickers whose options are positioned in unique or interesting ways, rather than the traditional stacked list of options.
  • form-fields-automatically-fit-contents : Allow form fields to grow and shrink to fit the user input, e.g. as the user types or selects a different option. Apply maximum and minimum size limits to create dynamic and responsive form fields that conform with the page design.
  • ime-safe-enter-submit : Implement Enter-to-submit in textareas and single-line inputs (chat, search, inline rename) safely for IME (Input Method Editor) users to prevent submitting incomplete text.
  • required-field-feedback : Provide error message for required form fields that were skipped or left empty only after user interaction, to avoid preemptive errors and ensure feedback is timely and contextually relevant to the user's flow.
  • rich-media-picker : Create a custom select component whose options can contain complex HTML formatting (e.g. images, icons, and other rich formatting) rather than just plain text.
  • select-menu-interaction : Validate that a non-default option has been chosen in a select menu only after the user has interacted with the control.
  • slider : Style a native range slider with custom track, thumb, fill, and focus states while preserving native functionality and accessibility.
  • sms-otp-form : Verify user phone numbers and one-time passcodes delivered over SMS with automatic code extraction and accessible form input.
  • switch : Build an accessible switch with the native HTML switch attribute, falling back to a styled checkbox when not supported.
  • validate-input-after-interaction : Show form field validation feedback (e.g. password complexity or email format requirements) only after the user has finished their initial interaction, avoiding premature errors on page load or while the user is typing.

html

  • accessible-web-components : Make custom elements accessible by default, setting roles and ARIA state via the ElementInternals ARIA mixin, managing focus with delegatesFocus, and keeping ARIA relationships within a single shadow root.
  • custom-elements : Define, register, and manage the lifecycle of autonomous custom elements, covering constructor rules, lifecycle callbacks, upgrade timing, attribute/property reflection, and naming conventions.
  • form-associated-custom-elements : Make a custom control participate natively in forms with formAssociated and ElementInternals, submitting its own value, integrating with constraint validation, and reacting to reset, disable, and state-restore.
  • prerendering-custom-elements : Server-render a custom element, then hydrate it in place without re-rendering or a flash of unstyled content.
  • shadow-dom : Encapsulate a component's DOM and styles with Shadow DOM, construct the tree efficiently with HTML templates, and project consumer content with slots.
  • styling-web-components : Style across the shadow boundary with :host selectors, inherited and custom properties for theming, ::slotted and ::part, and cascade layers and container queries inside components.
  • web-components : Orientation and cross-cutting principles for authoring and using Web Components, covering Custom Elements, Shadow DOM, templates and slots, Declarative Shadow DOM, styling across the shadow boundary, Form-Associated Custom Elements, and accessibility requirements. Use this guide when building reusable UI components, design systems, or server-rendered custom elements.

js

  • calculate-event-differentials : Calculate elapsed or remaining time between dates and times, balance duration units, and format human-readable localized durations using Temporal.Duration and Intl.DurationFormat.
  • capture-location-agnostic-data : Model location-agnostic calendar dates, wall-clock times, partial dates (recurring birthdays, credit card expirations), and recurring monthly intervals without time zone drift using Temporal Plain types.
  • coordinate-global-events : Schedule future meetings or events by explicitly binding them to a geographical IANA time zone so that event times remain accurate regardless of Daylight Saving Time (DST) transitions, "skipped" or "repeated" hours during clock changes.
  • sort-high-precision-timestamps : Parse, sort, and measure intervals between sub-millisecond or nanosecond ISO 8601 timestamps without Date truncation collisions using Temporal.Instant.
  • support-global-calendar-systems : Display and calculate dates in non-Gregorian calendar systems (e.g., Islamic, Hebrew, or Chinese) accurately for international users.

performance

  • batch-analytics-events : Debounce and batch multiple analytics, telemetry, and Core Web Vitals events together in a single beacon to minimize network contention and reduce server load, while still delivering real-time updates.
  • break-up-long-tasks : Break up heavy synchronous processing (complex computations and/or long loops) or DOM updates to improve Interaction to Next Paint (INP) responsiveness and let the browser handle user input and repaint the screen.
  • calculate-total-foreground-time : Calculate the total time a user actually spent viewing a page, excluding periods when the tab was in the background.
  • conditional-async-dependencies : Conditionally load or initialize async dependencies (such as importing polyfills for missing web features) without requiring complex orchestration across all of a page's script dependencies.
  • defer-rendering-heavy-content : Reduce rendering times in content-heavy web pages (e.g. pages with long feeds, lots of articles, or complex dashboards), by deferring rendering for any content that is not immediately visible to the user.
  • defer-work-until-scroll-ends : Defer expensive operations like DOM updates, data fetching, analytics tracking, or layout recalculation until after scrolling completes to maintain smooth scroll performance.
  • deliver-optimized-decorative-images : Deliver optimized decorative images (such as backgrounds, UI icons, or complex masks) by simultaneously providing next-generation image formats (like AVIF or WebP) alongside multiple pixel densities (like 1x and 2x) so the browser can dynamically negotiate the best combination of file size and visual quality for the user's device capabilities.
  • deprioritize-background-fetches : Deprioritize background data fetches made with the Fetch API to prevent network contention with user-initiated requests.
  • detect-initial-visibility-state : Reliably determine whether a page was initially loaded in the background, even in cases where the script is loaded asynchronously after the user foregrounded the page.
  • efficient-background-processing : Conserve system resources and battery life by pausing background JavaScript execution (such as &lt;canvas&gt; animations, WebGL rendering, or high-frequency WebSocket data polling) when the component is off-screen and then resume them just-in-time when they scroll back into view.
  • faster-spa-view-transitions : Enable faster transitions back to previously visited views in a Single-Page Application (SPA) by preserving their structural DOM state instead of destroying and rebuilding them on every navigation.
  • flicker-free-client-side-ab-testing : Deliver and render A/B tests, multi-variate tests, or other experiments using client-side JavaScript to alter or inject HTML, CSS, and JavaScript without the original content showing first before flickering or flashing to show the experiment content.
  • full-session-analytics : Reliably track analytics, Core Web Vitals, errors, and telemetry data across the user's entire page visit, and defer sending of the data until the user leaves the page.
  • identify-heavy-scripts : Identify the scripts most responsible for long animation frames
  • identify-inp-causes : Identify slow-running JavaScript and other causes of poor Interaction to Next Paint (INP) responsiveness.
  • improve-next-page-load-performance : Improve page load performance by prefetching or prerendering pages that the user is likely to visit next.
  • interaction-paint-timing : Measure the time it takes for user interactions and client-side navigations to render new contentful updates on screen.
  • interactions-in-complex-layouts : Make interactions snappier and more responsive (reducing Interaction to Next Paint (INP) scores) by avoiding layout re-calculations in complex layouts, such as data-heavy dashboards or spreadsheet-style grids.
  • lazy-load-video-and-audio : Defer downloading offscreen video and audio assets, including video poster images and preloaded media data, until the media player approaches the viewport to conserve bandwidth and reduce network contention during initial page load.
  • optimize-image-priority : Optimize the loading priority of Largest Contentful Paint (LCP) candidate images and deprioritize non-critical images to reduce critical resource load delays.
  • optimize-preload-priority : Optimize the relative priority of preloaded content to reduce critical resource load delays.
  • optimize-script-priority : Optimize the loading priority of scripts by boosting critical asynchronous scripts and deprioritizing non-essential or late-body scripts to improve sequencing and reduce delays.
  • out-of-order-html-streaming : Declaratively update a page with content streamed later into the same HTML document or via imperative JavaScript APIs.
  • resolution-optimized-pseudo-elements : Use resolution-optimized images in CSS pseudo-elements (such as ::before and ::after ) to reduce the number of DOM nodes.
  • schedule-tasks-by-priority : Schedule tasks with different priorities to ensure critical work runs first while background work is deferred.

privacy

  • privacy : Action-oriented guidelines for web developers to implement privacy by design, data minimization, third-party audits, and secure data handling. Use this skill when designing applications, integrating third-party services, handling user data, or configuring security headers.

pwa

  • install-web-app : Install web applications from a page using browser-controlled consent UI.
  • migrate-web-app-origin : Transfer an installed web app to a new origin while preserving user configuration and OS-level shortcuts.

security

  • client-side-encryption : Establish shared secrets using public-key encapsulation or key agreement—including hybrid and post-quantum protection—and encrypt sensitive data in the browser with authenticated encryption.
  • digital-signatures : Sign and verify messages, tokens, or artifacts in the browser using classical or quantum-resistant (post-quantum) asymmetric keys to ensure data integrity and authenticity.
  • local-network-access : Access resources on a user's local network or loopback interface from a public web application.
  • passkey-authentication : Authenticate a returning user with a passkey for primary sign-in.
  • passkey-conditional-create : Silently register a passkey for an existing user after a successful password login.
  • passkey-management : Let users view and manage the passkeys registered to their account.
  • passkey-reauthentication : Verify a signed-in user's identity using their existing passkeys before a sensitive action.
  • passkey-registration : Register a passkey for an existing user account.
  • passkeys : Comprehensive orientation and cross-cutting principles for implementing WebAuthn and Passkeys in web applications. Use this guide when handling passkey registration, authentication, management, or reauthentication.
  • quick-sign-ins : Authenticate returning users in place with their saved passkeys or passwords before navigating to a sign-in page or interrupting their workflow.
  • restrict-outbound-connections : Restrict a page or worker to communicating only with an explicit allowlist of network endpoints to prevent unauthorized third-party requests and client-side data exfiltration.
  • sanitize-untrusted-html : Safely parse and display untrusted HTML content from user input by removing unsafe elements and attributes.
  • secure-external-subresources : Verify the cryptographic integrity of external scripts, stylesheets, fonts, and images loaded from third-party origins, and control whether those requests send credentials or referrer URLs.
  • trusted-types : Prevent DOM-based XSS attacks by defining a Trusted Types policy to sanitize untrusted HTML, using the policy when writing to DOM sinks like innerHTML, and enforcing Trusted Types via Content Security Policy.
  • validate-origins : Compare and validate web origins and sites safely across cross-document messages and URLs without error-prone string parsing.
  • verify-email-ownership : Verify that a user owns an email address during account creation, sign-in, or recovery without sending a one-time passcode or magic link email.

ui-atoms

  • carousel-slide-effects : Create a carousel of slides with images or other visual elements, where each slide animates as they enter/center/exit their scroller. For example, the slides may fade-in/fade-out, rotate, get bigger or smaller, etc.
  • component-specific-light-dark-theme : Force certain elements to be in light mode or dark mode (e.g. code blocks, media players, etc) independently of the page's color-scheme.
  • icons : Display and manage icons that can be set and parameterized from CSS, are fast to load, crisp at any resolution and are properly exposed to (or hidden from) assistive technologies.
  • position-aware-tooltips : Build tooltips and popovers with directional arrows (or other visual styling) that automatically point the correct way when the element flips to a fallback position.
  • pull-to-reveal : Build a pull-to-reveal feature that would enable the user to pull down on the screen to reveal more content, like a search bar.
  • responsive-table : Build a data table that presents tabular data with proper header semantics, and remains readable and navigable on small screens and with assistive technologies.
  • scroll-position-aware-elements : Build floating buttons or widgets (back-to-top, scroll-to-bottom, chat launchers, etc.) that appear and disappear based on whether the user has scrolled at all.
  • scroll-progress-indicator : Create a scroll progress bar, stepped progress tracker, or any visual affordance that communicates how far through a page or section the user has scrolled.
  • scrollability-affordance-hints : Build scroll shadows or fading edges that appear only when there's actually more content to scroll to in that direction.
  • shrinking-header-on-scroll : Smoothly animate a fixed header or full-page cover on scroll to dynamically shrink, gain shadows, and transform its layout over a predefined scroll distance.
  • single-line-overflow : Show text that must stay on one line, such as a tab label, table cell, navigation item, or file name, in a space it may not fit, without breaking the layout or losing the text.
  • state-aware-sticky-headers : Build sticky section headers or navbars that visually transform when they're actually "stuck" at the top, changing their color scheme or gaining a shadow.
  • viewport-aware-dropdowns : Position dropdowns, flyouts, or contextual action panels tethered to a trigger button so they automatically flip axes at viewport edges instead of getting clipped.

ui-behaviors

  • 2d-panning : Allow users to freely pan or scroll two-dimensional surfaces—such as maps, zoomed images, infinite canvases, or large data grids—across both directions (whether diagonally or changing direction mid-gesture) without the gesture locking to a single horizontal or vertical axis.
  • anchor-positioning-tab-underline : Transition an element seamlessly between two target element positions. For example, moving a selected tab underline between the previously selected tab and the currently selected tab.
  • animate-element-entry-exit : Smoothly hide/show elements as they are added/removed from the DOM or as their display values are toggled.
  • animate-to-from-top-layer : Animate elements such as dialogs, popovers, and tooltips as they're entering/exiting the top layer.
  • carousel-snap-highlights : Visually highlight the currently snapped non-interactive item in scroll-snapping carousels, galleries, or full-page swipe experiences. For example, expanding a card when snapped, or revealing hidden content.
  • consistent-cross-document-transitions : Ensure critical page state is loaded and stable before initiating a cross-document view transition. This means critical CSS styles are loaded and applied, critical JavaScript is loaded and run, and the HTML visible for the user's initial view of the page has been parsed before the transition runs.
  • cross-document-transitions : Create smooth, seamless transitions between full page navigations, such as cross-fades, custom reveal effects, or morphing of content from one page to the next.
  • custom-button-actions : Declaratively connect a button to any element to trigger custom, application-specific actions using declarative button commands, invoker commands, button commands, custom commands, or declarative toggle actions.
  • declarative-dialog-popover-control : Toggle the visibility of a dialog or popover from a button without writing JavaScript.
  • directional-navigation-transitions : Animate visual state changes to reflect the direction of a user's navigational flow, such as sliding new content in from the right when advancing forward or from the left when returning to a previous screen.
  • drag : Support dragging to move a floating element around the page.
  • drag-and-drop : Support dragging to rearrange the children of a container along one axis (horizontal or vertical) while preserving their state and accessible order.
  • dynamic-sibling-animations : Stagger animation or transition timing across sibling elements so each one starts after a computed delay based on its position in the sibling list.
  • dynamic-sort : Best practices for handling dynamic user-triggered reordering of a container's children (e.g. list items, table rows, or a card grid), with optional animated reordering that respects user preferences, good screen reader UX, and optimal performance for large lists.
  • group-element-transitions : Smoothly rearrange and animate list items, cards, or grid elements into their new positions simultaneously when adding, removing, shuffling, or reordering—such as removing a product from a shopping cart.
  • highlight-text-ranges : Highlight arbitrary text ranges on a page such as search results, spelling errors, or collaborative editing cursors.
  • interactive-content-reveal : Create interactive reveal effects, such as a spotlight that follows the user's pointer to uncover details within an image or UI section.
  • interest-triggered-action-previews : Show a live preview of a button's effect when a user signals interest (e.g. hovering, focusing, or long-pressing) but before they commit to clicking.
  • interest-triggered-tooltips : Show a tooltip or supplemental information when a user hovers over, focuses on, or long-presses an interactive element, without requiring a click.
  • light-dismiss-a-dialog : Create a modal dialog that can be closed via light dismiss (i.e. clicking or tapping outside of the dialog)
  • motion : Animate UI with CSS transitions, animations, scroll-driven animations, and view transitions while keeping motion on the compositor and respecting reduced-motion preferences.
  • move-dom-element-without-losing-state : Move or reparent a DOM element without losing important element state, such as interactivity states (:focus/:active), &lt;iframe&gt; loading state, animation/transition state, etc
  • parallax-scroll-effects : Create scroll-based effects (such as parallax) where foreground and background layers move at different rates, creating a sense of depth as the user scrolls.
  • persistent-top-layer-ui : Keep a modal dialog, fullscreen element, or native popover visibly open and functionally active when its underlying DOM node is moved or reparented in the DOM.
  • physics-based-easing : Create custom, physics-based animation and transition effects, like bounce and spring, that feel more natural and engaging than traditional easing curves.
  • platform-controls-dismiss-dialog : Create a modal dialog that can be closed via standard platform-specific user actions, such as pressing the Esc key on desktop platforms, or a "back" or "dismiss" gesture on mobile platforms
  • prevent-page-scroll-under-modal-dialog : Prevent the underlying page from scrolling while a modal dialog is open.
  • same-document-transitions : Visually connect persisting elements across different page states or navigations in a Single Page Application (SPA) (e.g. expanding a product thumbnail into a full-bleed hero image) by smoothly morphing their size, position, or other styling properties.
  • scoped-component-transitions : Animate state changes inside a single component (a card, list, panel, or other subtree) while the rest of the page remains interactive, and other transitions run concurrently.
  • scroll-completion-effects : Trigger visual effects, animations, or focus changes on a target element only after a smooth programmatic scroll to that element has finished.
  • scroll-entry-exit-effects : Create fade-in, scale-up, or other complex reveal-type effects on elements as they enter and exit the scrollport (or viewport) while the user is scrolling.
  • scroll-snap-realtime-feedback : Provide real-time visual feedback in linked UI elements while a user scrolls through snap-aligned content, before the scroll gesture completes.
  • scroll-snap-state-sync : Synchronize navigation indicators, linked content panels, and analytics tracking with the actively snapped item in a scrollable container.
  • scroll-target-on-load : Build a scrollable list of elements (e.g. a carousel of images or a chat conversation thread) that can be displayed with a particular element scrolled into view on the initial render.
  • scrollytelling : Animate visual properties on a target element — such as fading a backdrop, shifting a background color, or to create scrollytelling experiences — driven entirely by the scrollport position of a completely different element.
  • search-hidden-content : Hide content from view using patterns such as accordions, tabs, and "Read more" sections, while ensuring the hidden text reveals itself during native "Find in page" searches, allows search engine indexing, supports URL fragment deep links, and maintains ARIA accessibility.
  • sortable-table : Progressively enhance a data table with behaviors that allow users to sort rows by clicking on column headers.
  • spatial-navigation : Implement accessible spatial navigation using arrow keys that works correctly in different layout modes (grid etc)
  • swipe-to-remove : Let users act on items in a list (remove, archive, mark as read, etc.) with a horizontal swipe gesture, so they can process entries quickly without tapping a separate control.
  • swipe-to-reveal : Let users swipe horizontally on a list item or content pane to reveal contextual action buttons or a side menu without automatically triggering an action.

ui-components

  • accordion : Build an accordion component with animation, optional exclusive (one-open-at-a-time) behavior, and brand-consistent styling.
  • app-menus : Build an application menu bar where several top-level menus (such as File, Edit, and View) act as a single keyboard stop and switch between each other on hover or arrow keys.
  • breadcrumbs : Build a breadcrumb trail that shows the user's location within a site hierarchy and lets them navigate to ancestor pages.
  • card : Build a card component that adapts its presentation to its own available space and contents.
  • carousel : Build a carousel component that displays a set of items in a horizontal or vertical layout.
  • checkbox : Style checkboxes, including custom icons, layout, colors, check/uncheck animations, while preserving native functionality and accessibility.
  • copy-button : Build a copy button that copies text from arbitrary elements to the clipboard.
  • dark-mode-toggle : Build a dark mode toggle component that allows users to override their system color scheme preference for the current site.
  • dialog : Build a modal or non-modal dialog component that is accessible, manages focus appropriately, and can be dismissed the way users expect on each platform.
  • hovercard : Build a hovercard component that displays an interactive structured preview of the page a certain type of link (e.g. a user profile) will navigate to when hovered over.
  • menu : Build a menu component that displays a list of options or actions, with support for nested submenus.
  • navbar : Build a site navigation bar that adapts across screen sizes and indicates the current page.
  • navigation-drawer : Create a navigation drawer component that, when triggered from a menu button, slides in from the side overlaid on top of existing page content, and slides out when dismissed (by swiping away, tapping outside, or pressing escape).
  • persistent-app-tours : Create persistent onboarding walkthroughs using tethered native overlays that stay open during user interaction.
  • persistent-toast-notifications : Create non-intrusive toast and overlay notifications for persistent, stackable messaging and state communication.
  • progress : Build a styled progress bar that communicates completion of a task or process, in both determinate and indeterminate states.
  • progress-ring : Build a progress ring component that visually represents the completion status of a task or process, with support for content in the center and brand-consistent styling.
  • scrollspy : Highlight the currently visible section of a page in a navigation menu
  • spinner : Build a loading spinner that communicates busy state to all users, respects reduced-motion preferences, and animates efficiently.
  • stack-drill-down : Build full-screen hierarchical navigation that lets users drill down into nested views and swipe or navigate back to return, with browser history kept in sync.
  • tabs : Build a responsive tabbed interface with good UX when not all tabs fit on screen.
  • toolbar : Build a toolbar component that displays a set of controls for performing actions.

user-experience

  • content-first-noise-reduction : Maximize content and reduce noise by removing blocking popups, keeping persistent navigation compact, and moving secondary content behind on-demand disclosure.
  • form-factor-adaptation : Adapt layouts, controls, and text to any device or container so touch targets stay usable, content fits its space, and nothing collides with system UI.
  • natural-interactions : Implement natural interactions with clear hover, focus, and press feedback, motion that opens from its trigger, swipeable content, and keyboard-reachable actions.

visual-design

  • adapt-scrollbar-to-contrast-preferences : Enhance scrollbar visibility for users who prefer high-contrast interfaces
  • apply-webgl-shaders : Apply custom visual effects with WebGL shaders to HTML content.
  • browser-ui-theming : Theme browser-generated UI such as text selection, scrollbars, form controls, and pickers with CSS instead of re-creating it with custom elements.
  • color : Color guidance for the web, including contrast requirements, light and dark color schemes, Forced Colors Mode, and generating tints and shades from a base color.
  • complex-shapes : Clip elements and their content to any free-form shape, like a symbol, brush stroke, or organic texture for more expressive designs.
  • contrast-color : Select a readable text color with sufficient contrast on a dynamic background color.
  • custom-text-decorations : Add text decorations such as underlines, overlines, strikethroughs, or entirely custom shapes, with reveal animations, custom offsets and end insets, and flexible ink skipping.
  • customize-scrollbar-color-and-thickness : Customize the color or thickness of a scrollbar
  • dark-mode : Implement dark mode support in a way that respects the user's light/dark theme preference and adapts browser UI (e.g. scrollbars, form controls, etc)
  • equal-width-text-lines : Make every line of a multi-line heading or lockup span the same width, as in poster-style or stacked-headline typography. Unlike justified text, the text itself is sized to the width rather than the spacing stretched
  • export-html-media-from-canvas : Capture and export dynamic HTML content as images or video frames from within canvas.
  • expose-canvas-content-to-browser-features : Expose content rendered in a canvas to browser features like assistive technologies, translation, or reading mode.
  • improve-text-layout-and-legibility : Improve the layout and legibility of short standalone text content, such as headings no longer than a few lines, by enabling the browser to apply evenly balanced line breaks when wrapping text.
  • interactive-content-in-3d-scenes : Integrate interactive HTML elements into a 3D scene.
  • precise-text-alignment : Achieve precise vertical alignment with text of any font. For example, exactly equal visual padding above and below text, or aligning text perfectly flush with adjacent icons or images.
  • shaped-cutouts : Combine multiple shapes to create complex cutouts or 'knockout' effects in elements, such as adding a notch to an element.
  • soft-edge-content-fade : Apply a transparency gradient to content edges to indicate further scrollable areas or to obscure payment-walled text.
  • typography : Typography best practices for the web, including font sizing units, line height, text wrapping and balancing, and fluid type that scales with the viewport.
  • visual-effects : Visual effects with CSS such as layered shadows, blend modes, gradients with predictable color interpolation, and patterns like stripes, checkerboards, dots, and pie charts built from gradients alone.
  • visually-stable-font-fallbacks : Define font styles such that text remains readable and visually consistent in the event that there's a swap between the preferred font and one of the fallbacks (or vice versa).
  • visually-stable-mixed-fonts : Define font styles such that text remains readable and visually consistent in situations where multiple fonts are used to render a single block of text.
  • visually-texture-content : Apply realistic weathering and texture patterns to elements to give them an organic, aged, or physical material appearance.

wasm

webmcp

  • agentic-forms : Expose client-side functionality as tools to AI agents by annotating standard HTML forms with WebMCP attributes.
  • agentic-javascript-tools : Programmatically register client-side JavaScript functions as tools for AI agents using the WebMCP Imperative API.
  • webmcp : Use this guide to implement WebMCP in browser applications, exposing client-side functionality as tools to AI agents via declarative or imperative APIs.

Safe Adoption of Modern Features

  • Progressive Enhancement & Nuanced Fallbacks : We distinguish between purely additive enhancements (like speculative preloading) which are safe to let older browsers silently ignore, and critical behaviors (like dialog controls or network beacons) where we write highly considered, low-overhead fallbacks.
  • Responsible Fallbacks : We prioritize lightweight, case-specific custom fallbacks (<50 LOC) or conditionally-loaded polyfills instead of heavy third-party bundles.
  • Gotchas & Quirks : We document hidden platform limitations, such as the 64KB payload quota for fetchLater() or macOS-specific scrollbar behaviors.
  • Baseline-Aware Integration : We leverage real-time compatibility data from the Baseline project so agents dynamically adapt to current browser support.
  • Origin Trial & Volatile Feature Gates : Guides covering experimental Origin Trial APIs or volatile features (single-engine features shipped within the last 3 months or still stabilizing) remain discoverable via search , but are gated on retrieve so agents do not adopt unstable APIs without explicit developer consent.

Project Configuration ( .mwgrc )

Configure Origin Trial and volatile feature opt-ins for a repository with an optional .mwgrc JSON file in your project root (or ~/.mwgrc as a user-level fallback), which you can commit to share across your team:

CLI Command .mwgrc Key Effect
npx modern-web-guidance@latest set-allow-origin-trials "allowOriginTrials": true Unlocks guides for experimental Origin Trial APIs.
npx modern-web-guidance@latest set-allow-volatile-features "allowVolatileFeatures": true Unlocks guides for volatile single-engine features.

How It Works

  1. Activation : The coding agent activates the modern-web-guidance skill because of a relevant task. The agent is instructed to use the modern-web-guidance CLI for web platform queries.
  2. Local Semantic Search : The agent runs modern-web-guidance search "<query>" . The tool matches the query to the best guide using an offline, zero-dependency embedding model and BM25 search engine (no network calls, no API keys).
  3. Guide Fetch : The agent retrieves the guide via modern-web-guidance retrieve <guide-id> , inserting targeted code patterns, gotchas, and fallbacks directly into its context window.

Tip

Note: We use npx to ensure the content doesn't go stale, but the CLI works offline, completely private and local. The npm package is self-contained, with no extra dependencies to ensure both low-latency and supply-chain security.

Alternative Installation Methods

Vercel Skills CLI (aka npx skills ) 
npx skills add GoogleChrome/modern-web-guidance
GitHub CLI 
gh skill install GoogleChrome/modern-web-guidance
Google Antigravity 
agy plugin install https://github.com/GoogleChrome/modern-web-guidance
GitHub Copilot CLI 
/plugin marketplace add GoogleChrome/modern-web-guidance
/plugin install modern-web-guidance@googlechrome
Claude Code Plugin 
/plugin marketplace add GoogleChrome/modern-web-guidance
/plugin install modern-web-guidance@googlechrome
/plugin  # Select GoogleChrome marketplace, press enter, enable AutoUpdate
/reload-plugins
Grok Build CLI 
grok plugin install https://github.com/GoogleChrome/modern-web-guidance --trust
Kimi Code 
/plugins install https://github.com/GoogleChrome/modern-web-guidance
OpenAI Codex 
codex plugin marketplace add GoogleChrome/modern-web-guidance
codex plugin add modern-web-guidance@googlechrome

Updating

If you installed the skill using npx modern-web-guidance@latest install , you can update with: npx modern-web-guidance@latest update .

Otherwise, consult your agent's documentation for updating plugins and skills.

Evals to prove this works well

We developed a robust eval harness to ensure that the content is empirically proven and continuously calibrated so AI agents write better code. We run automated evaluations using a closed-loop validation pipeline: 

  [ Expert-authored guidance and demo ]
            │
            ▼
  [ Target generation ] ──> Tasks on real webapps, Golden solutions, Playwright graders
            │
            ▼
  [ Calibration loop ] ───> Runs Grader on Golden Solutions (Must Pass 100%)
            │               Runs Grader on Unmodified Base App (Must Fail 100%)
            ▼
  [ E2E agent evals ] ────> Runs coding agents in guided vs. unguided modes
                            Compares pass rates and accessibility w/ and w/o the skill
  1. Simulated Developer Tasks : We define realistic developer prompts against full base applications ( daily-grind , devtools-times ) that mimic real-world requests (e.g., "make my images load faster"). Prompts avoid naming APIs or features, testing whether the agent can naturally discover and apply the right guides.
  2. Static & Browser-Based Assertions : Playwright graders verify that each implementation requirement was followed—checking source patterns, computed styles, runtime DOM behaviors, and accessibility states.
  3. Self-Healing Calibration : Graders are calibrated against multi-agent (Claude/Codex/AGY) golden solutions (100% pass target) and an unmodified baseline application (0% pass target).
  4. E2E Testing : We measure coding agent performance on real tasks with and without guidance. The opportunity (100% - unguided pass rate) and uplift (guided - unguided pass rate) are key: if models already succeed without guidance, we prune redundant advice; where agents struggle, we refine guides to maximize uplift.

Recent eval results snapshot

Explore full per-agent and per-guide breakdowns on the Eval Dashboard .

Date Agent + Model Tasks / Assertions Unguided → Guided (Uplift)
Nov 8 antigravity_cli (gemini-4-argon) 214 / 1673 58% → 94% ( +36pp )
Nov 8 codex_cli (gpt-6.1-sol) 215 / 1795 54% → 82% ( +28pp )
Nov 8 claude_code (opus-5-5) 215 / 1801 57% → 88% ( +31pp )
Nov 6 codex_cli (gpt-6.1-sol) 212 / 1773 53% → 86% ( +33pp )
Nov 6 claude_code (opus-5-5) 212 / 1773 56% → 90% ( +34pp )
Nov 6 antigravity_cli (gemini-4-argon) 212 / 1722 60% → 96% ( +36pp )
Nov 4 codex_cli (gpt-6.1-sol) 209 / 1743 52% → 85% ( +33pp )
Nov 4 claude_code (opus-5-5) 209 / 1743 57% → 90% ( +33pp )
Nov 4 antigravity_cli (gemini-4-argon) 207 / 1722 60% → 96% ( +36pp )
Nov 2 codex_cli (gpt-6.1-sol) 205 / 1729 55% → 82% ( +27pp )

Available Skill Packs

You can customize which skill packs are installed using the --choose flag: 

npx modern-web-guidance@latest install --choose
  • modern-web-guidance (~205 tokens): Comprehensive guidance on modern browser APIs, layouts, and performance.
  • chrome-extensions (~175 tokens): Guidance on Manifest V3, background workers, extension APIs, and Chrome Web Store publishing.

Telemetry & Privacy

Google collects anonymous usage information to improve the tool's reliability, relevance, and performance. Collected information includes installation counts, the calling agent name, guide retrieval IDs, and CLI tool search queries generated by the agent (e.g. "dark mode scrollbar color-scheme"). Raw user prompts are not collected. You can inspect what is collected in modern-web.ts .

Tip

To Opt-Out: set the DISABLE_TELEMETRY=1 env variable in your shell profile (e.g., .bashrc or .zshrc ): 

export DISABLE_TELEMETRY=1

Google handles this data in accordance with the Google Privacy Policy .

Contributors

Found a bug, outdated pattern, or missing web platform feature? Open an issue or see CONTRIBUTING.md in the source repository ( GoogleChrome/modern-web-guidance-src ) .

Huge thanks to everyone who has contributed!

License

Unless otherwise noted:

Portions of the documentation in this project are derived from MDN Web Docs by Mozilla Contributors and W3C , WHATWG , and IETF specifications.

Claude Whiteboards, Claude Sheets, and Claude Data

Hacker News
claude.com
2026-11-10 12:55:07
Comments...
Original Article

Today we’re launching Claude Whiteboards and Claude Sheets in beta, and Claude Dashboards (opens in new tab) becomes generally available as Claude Data. Whiteboards is a shared board where your team brainstorms with Claude, Sheets is a spreadsheet Claude builds and edits with you, and Claude Data adds data stories, certified queries, and live sharing. These are available on all paid plans.

Working with Claude on a project often meant moving the output over to another tool or program, where Claude didn’t have live access to follow progress and changes. Now, your documents, boards, sheets, and dashboards can stay in Claude, with access for your team to continue editing together. When ready, you can bring the outputs directly into tools from our partners and continue working there.

Claude Whiteboards

Many people use Claude as a thought partner, but brainstorming with it has typically meant copy-pasting the results elsewhere so you can then start brainstorming or collaborating with your coworkers. Now, you can talk through a messy plan out loud with Claude, and Claude can turn it into a board with a timeline with owners and dates, so you and your team can collaborate in real time. In a retro meeting, for example, everyone can add their notes, and Claude can group them by theme and draft the action items for each person. You can focus on any part of the board by dragging a box around it and asking Claude questions. When you’re done brainstorming, Claude can turn the board into a doc or deck, or bring it into tools like Lucid, Miro, or Vani by Zoho, where you can continue working on it with your team.

Claude Sheets

Claude can now generate spreadsheets with tabs, formulas, formatting, and drop-downs, often from just a prompt like asking for a campaign tracker or a hiring budget. It can edit in the cells, outlining each new edit so you can track changes. You can share sheets with your team, so you and Claude can work on them together.

For now, sheets have simple spreadsheet functionality, but we are working on adding more. When you need the full functionality of Excel, you can export your file to .xlsx or CSV, or use Claude for Excel (opens in new tab) . You can also continue working in partner tools including Airtable, Asana, monday.com, and Smartsheet.

Claude Data

Claude Dashboards (opens in new tab) launched in beta in October, enabling teams to ask quick questions of their company’s data in tools like Amazon Redshift, BigQuery, and ClickHouse. Starting today, it’s generally available as Claude Data. We changed the name because the way companies use their data is broader than dashboards, and the product now covers how they work more broadly. Certified queries and live sharing are in beta. Here are some ways teams can use Claude Data:

  • Create certified definitions of metrics. Your data team can certify the queries everyone should use, so you don’t end up building or working on dashboards with conflicting data. Charts built on these metrics carry a "certified" badge showing they’re certified.
  • Craft stories from data. You can work with Claude in Claude Data to draft data stories or narrated videos from your metrics, for you to review before sharing.
  • Share current numbers with everyone. With live sharing, your colleagues can see up-to-date numbers when they open a shared dashboard, even if they don’t have access to the connectors that keep that data current. Viewers see dashboard results rather than the underlying data, and they can run only the queries you’ve approved.
  • Match your look-and-feel. Design systems are now supported in Claude Data.
  • Get faster loading with caching. Previously, every dashboard would reload on every load. Now, dashboards support caching, and refresh cadences can be set on a per-dashboard basis.
  • Track changes over time. Claude Data now has tracked changes, so you can see who has made edits and roll back to a specific version if needed.

Our partners for Claude Data include Amplitude, Mixpanel, Omni, PostHog, and Sigma.

Starting today, interactive connectors (opens in new tab) can open as full apps beside your conversation or in full screen, so you can work in tools like Adobe, Atlassian, Box, and Notion yourself, or ask Claude to make changes with you.

Getting started

Claude Whiteboards, Sheets, and Data work on web, desktop, and mobile. Claude Data needs a data connector, such as a warehouse or CRM.

For admins: On Team plans, all three are on by default. On Enterprise plans, Claude Whiteboards and Sheets are off by default, and Claude Data turns on by default on November 19, 2026. You can change these anytime in Organization settings > Artifacts.

An Open Field Guide to Inference Engineering

Hacker News
docs.modelplane.ai
2026-11-10 12:55:07
Comments...
Original Article

Numbers, prices and tool versions are as of October 2026.

This guide is for platform engineers new to inference. If you need to understand how models and GPUs work together and how to run inference in production, this guide will help. You’ll also learn about the tools to use and how to grow into an inference engineering role.

This guide builds on the work of others in the inference community. If you’re interested in inference engineering, continue your learning with these:

1. Why now?

In an AI-forward organization, platform teams become inference teams. Coding assistants can’t send source code to third parties, and frontier model bills increase month to month. Support tools also need internal data that a hosted model can’t reach.

Organizations want to run these models themselves, and open models now make that practical.

Hugging Face hosts more than two million open models, and the best of them compete with closed models. DeepSeek released R1 in January 2025, and it matched OpenAI’s o1 on math and coding benchmarks about a month after o1 came out . When you run your own model, you control latency, uptime, and where your data goes. At high volume, you can also cut costs by about 80% .

The work suits platform engineers. The price of a fixed level of AI capability falls roughly 10x a year, and most of that comes from how models are served, not from better GPUs . Upbound, the company behind Crossplane and Modelplane, saw this firsthand. In its Project Champagne blog series, the team ran its own models on Modelplane and found that vLLM and scheduling worked. The time went to TLS, identity, timeouts, storage, IAM and observability.

Skills that carry over

An inference engineer picks a model, gets it onto the right GPU, keeps it serving, makes it faster and cheaper, and gets paged when it breaks. That’s SRE for a new workload, and most of your skills carry over:

What you already know What it becomes in inference
Scheduling and node pools GPU placement with device selectors, taints and exclusive devices
Capacity planning GPU memory math: weights, KV cache and runtime overhead, checked at runtime
Load balancing Cache-aware routing and long-lived streaming connections
Autoscaling on CPU Scaling on queue depth and KV cache use, with cold starts measured in minutes
Rollouts Rollouts of exclusive GPUs, and a version matrix of model, hardware and engine build
SLOs and latency percentiles Time to first token, time per output token and goodput
Observability Engine metrics, real GPU activity and speculative decoding acceptance
FinOps Cost per million tokens and cost per user session
Identity and access Credentials that last as long as an agent session

A hosted API is still the right call early in a product’s life . Self-hosting pays off when API spend becomes a real line item, when latency or reliability needs outgrow vendors, or when data can’t leave your network. In August 2026, Chris Zeoli counted about 58 open inference roles on public careers boards, with no settled job title.

2. Inference 101

This section covers the concepts in roughly the order you’ll meet them. Most are about what the engine keeps in GPU memory or what limits its speed.

Viktor Farcic suggests asking when each concept starts to matter. Some matter as soon as you deploy, others only once many people use the model, and some you may never need. The table near the end of this section gives the signal for each.

What an inference engine is

An inference engine, like vLLM or SGLang , is the server that turns model weights into an API. For a platform engineer, the closest mental model is a stateful database server with a GPU attached. It loads a large dataset into memory at startup and keeps per-session state. It also schedules work internally and answers over HTTP. Ollama on a laptop is the same idea at small scale, and every hosted model API runs one behind the scenes.

You know this from databases and services The engine’s counterpart
Loading a dataset into the buffer pool at startup Loading model weights into GPU memory, which can take many minutes
Per-session state in a session store The KV cache, one for each conversation in flight
A query planner and connection pool The scheduler, which batches requests into each GPU pass
A wire protocol clients already speak An OpenAI- or Anthropic-compatible HTTP API
Warming caches after a restart Cold starts: pulling a large image and reloading the weights

Unlike a database, the engine keeps its working set in GPU memory, not RAM. GPU memory is small and expensive, so most tuning is about deciding how much of it each request gets.

The inference stack

The engine is one layer of four. At the bottom, kernels do the arithmetic. You rarely choose them directly. Above them sits the engine . Above that, a control plane deploys and manages engines, because sooner or later you run more than one. On top, a gateway routes traffic across models and replicas.

Inference stack: four layers and the clients they serve

Inference stack: four layers and the clients they serve

Requests pass through the gateway to an engine, which runs kernels on the GPU. The control plane deploys and manages the gateway and engines, but no request passes through it.

Tokens

A token is the unit a language model works in, roughly a word or word fragment. Context windows, prices and speeds are all counted in tokens. When someone quotes tokens per second, they mean this unit.

Weights and the KV cache

The weights are fixed, and the KV cache grows with load. Size for both, as you would a database’s footprint and working set.

Weights are the fixed footprint. Most models are released at 2 bytes per parameter (BF16 or FP16), so an 8B model needs about 16 GB, and it has to live in GPU memory, not system RAM. On a 48 GB L40S, that leaves about two-thirds of the card for everything else. That number is the same for one user or a hundred.

The KV cache is the working set. Each new token is computed against every token before it. Rather than recompute that history, the engine keeps the attention keys and values for every token in flight. Its size scales with context length multiplied by the number of concurrent conversations, much like a session store that grows with both session size and user count.

You can estimate the KV cache per token from a model’s config: 

KV bytes per token = 2 × layers × KV heads × head dimension × bytes per value

For Llama 3 70B at FP16 (80 layers, 8 KV heads, head dimension 128), that is about 320 KB per token. One 128K-token conversation needs about 40 GB of cache. At that size, the KV cache usually limits how many users a GPU can serve.

Watch for these sizing mistakes:

  • Mixture-of-experts (MoE) models keep every weight resident. A model with 320B total parameters and 18B active still needs about 320 GB at FP8. Only compute scales with the active parameters.

  • Read the checkpoint size, not the dtype table. While self-hosting its own models for Project Champagne , Upbound estimated one MoE model at about 315 GB from its dtypes (Part 2). The real checkpoint was 177.7 GB, because the experts were stored in a 4-bit format.

  • Leave room for runtime overhead. CUDA graphs, activations and memory fragmentation all take space. A model that fits at startup can still run out of memory days later ( Project Champagne, Part 2 ).

Two phases, two bottlenecks

Each request runs in two phases on the same GPU, and they are limited by different things .

Phase What it does Limited by Metric it sets
Prefill Reads the whole input in parallel, including the system prompt and tool definitions as well as the conversation history. Produces the first token and the KV cache. Compute Time to first token (TTFT)
Decode Writes the answer one token at a time. Each token needs a pass that reads all active weights, plus the KV cache, from memory. At long context, reading the cache can cost more than reading the weights. Memory bandwidth Time per output token and tokens per second

Generating one token does one or two floating-point operations per byte read from memory, depending on weight precision. An H100 needs about 295 operations per byte to stay busy. That means one request uses a small fraction of the chip while the compute units wait on memory ( Data Gravity ).

Peak compute has grown about 3x every two years, against about 1.6x for memory bandwidth. Nearly every optimization either moves fewer bytes per token or spreads each byte across more tokens.

Because the phases have opposite bottlenecks, a technique that speeds one often does little for the other. That is why benchmarks report TTFT and tokens per second separately.

Metrics to track

Metric What it measures Watch out for
Time to first token (TTFT) Queueing plus prefill: how long the user waits before anything appears With reasoning models, the engine’s first token may be hidden thinking. Measure the first token the user sees.
Time per output token, or inter-token latency Decode speed per stream Speculative decoding and memory bandwidth show up here
Tokens per second per user Interactivity, or the model’s typing speed Falls as batch size rises
Throughput Total tokens per second across all users Rises as batch size rises
Goodput Throughput that still meets your latency targets The number to plan capacity with
End-to-end latency Total request time Depends on how much the model writes. A healthy 190-second answer is normal for long generations.
Percentiles p50, p90, p99 of each latency Users feel the tail, not the average
Errors and refusals Failed or rejected requests Count refusals as errors, or a context cap can look like a speedup
Cost per million tokens GPU cost divided by tokens served Compare at the load you actually run

Cost per million tokens converts a GPU price and a throughput into one comparable number: 

Cost per million tokens = GPU cost per hour / (tokens per second × 3600) × 1,000,000

Spheron’s worked example: a GPU at $2.90 an hour sustaining 1,200 tokens per second costs about $0.67 per million tokens.

Latency versus throughput

Batching more requests together raises total throughput and slows each individual user. Interactive chat and coding favor latency. Overnight batch jobs favor throughput.

It’s the same trade-off as tuning a database for transactions or for analytics. Write down the workload’s constraints before you tune anything.

When to adopt each concept

Each row gives the symptom that tells you it’s time to act, in roughly the order teams need them.

Concept What it does The signal that you need it
Fitting the weights Choose a model, precision and GPU so the weights fit with room to spare The engine fails to start, or starts with almost no KV cache left
Continuous batching and paged KV cache Share each GPU pass across requests, and hand out cache in small blocks Already on by default in vLLM and SGLang. Check it, don’t build it.
Quantization Store weights in fewer bits, and give the freed memory to the KV cache Requests queue while the GPU still has compute to spare
Prefix caching Reuse the work already done on repeated prompt openings Already on by default in vLLM and SGLang. Watch the hit rate once your clients are agents or chat apps that resend long histories
Speculative decoding Draft several tokens and verify them in one pass Individual responses stream too slowly, even at low load
Gateway and control plane Route between replicas, and manage engines declaratively You add a second model, a second replica or a second cluster
Sharding across GPUs Split one model with tensor, pipeline or expert parallelism The model will not fit on one GPU. Plan this before you deploy.
Autoscaling Add and remove replicas on queue depth and KV cache use Idle GPUs show up on the bill, or queues build at peak hours
Disaggregation Run prefill and decode on separate GPUs Long prompts stall streaming at scale, and you have RDMA-class networking

Most teams need only the first few rows on day one. Add the rest when their signals show up.

What agents change

Coding agents and other agentic workloads stress every part of this picture. Upbound measured this in Part 5 of its Project Champagne series (introduced in Section 1), where about 10 of its engineers ran Claude Code and other coding agents against a self-hosted model. Their traffic looked like this:

  • Prompts are long. The median prompt was 59K tokens and the p90 was 125K.

  • Prompts are mostly repeated. About two-thirds of prompt tokens hit the prefix cache, because agents resend their transcript on every turn.

  • Thinking is hidden. A reasoning model can think for more than a minute before its first visible token. Every timeout between the agent and the model has to allow for that.

  • Load depends on the client. Short-prompt sessions launch subagents and can keep more requests in flight than long-prompt sessions. Plan capacity in requests in flight rather than seats.

  • Sessions run for hours. Streams, tool calls and credentials all have to keep working for that long.

3. Running inference in production

In production, every choice trades latency, throughput, cost and quality against each other, usually with too few GPUs. Where a practice comes from Project Champagne, Section 5 has the details.

3.1 Start from use cases, not hardware

Each use case sets different requirements. In Project Champagne:

  • Coding agents needed long context without quality loss, reliable tool-call parsing, streaming, sessions that last hours, and an Anthropic-compatible API for Claude Code.

  • Chat needed low time to first token, real concurrency, and an OpenAI-compatible API for existing tools.

  • The platform needed TLS on a real hostname and identity tied to the company domain. It also needed observability that tells a healthy engine from a busy one, and correct placement without babysitting.

Separate interactive workloads from batch workloads. They need different targets, and often different deployments. Write the pass and fail bar down before you test anything.

3.2 Pick models deliberately

  • Evaluate on your own tasks. Public benchmarks measure someone else’s workload. Section 3.11 covers how.

  • Start small, then grow. A small MoE model with a few billion active parameters builds operating experience faster and costs less to get wrong.

  • The newest model is not always the right one. Model releases move faster than hardware plans. A new ‘small’ flagship can need several of the largest cards, while your current model may be running at half its supported context. The cheapest gain may not need a new model at all.

  • Check that your engine can actually load it. A model listed as supported in release notes may still fail to load on your hardware and engine build.

  • Check the license. Most open models use permissive licenses, but some restrict commercial use.

  • Check the chat template and parsers. Tool calls and reasoning output depend on settings each model needs in the engine. A wrong one breaks tool use while every request still returns 200.

3.3 Size for runtime, not startup

A model that fits at startup can still run out of memory under real traffic when fragmentation pushes past the profiled peak. That can happen days later, in the middle of a request.

  • Budget all three costs: weights, KV cache, and runtime overhead such as CUDA graphs and activations.

  • Know what your engine’s memory setting covers, and check again on every upgrade. vLLM sizes its KV cache from a startup estimate of everything else, including CUDA graph pools, and real traffic can go past that estimate. If you see out-of-memory errors under load, lower the memory fraction slightly, enable expandable segments and cap concurrent sequences, then measure free memory again.

  • Cap every request. Set a maximum output length on every call. Without one, any request can take a model down for everyone, and abandoned requests keep generating after the client gives up.

  • Shorten context with care. A shorter maximum context frees KV cache for more users. It also rejects every longer conversation, so count those rejections as errors.

3.4 Know the optimization techniques

Most engines turn on continuous batching and paged KV cache by default. The rest are choices you make per model and workload.

Technique What it improves Cost or risk Use it when
Continuous batching Throughput. Orca reported 36.9x over a static baseline at the same latency. Per-user speed drops as batches grow Always. It is the default in modern engines.
Paged KV cache ( PagedAttention ) Concurrency. vLLM cut KV cache waste from 60 to 80% to under 4%. Little in practice Always. It is the default in vLLM.
Prefix caching TTFT and prefill cost on repeated openings Only helps up to the first token that differs System prompts, RAG, multi-turn chat and agents
Weight quantization Decode always, and prefill only when activations are quantized too, as with FP8. Weight-only formats such as AWQ and GPTQ speed up decode alone. One step down in precision is typically 30 to 50% faster (Inference Engineering). Quality loss, which you must measure Use the lowest precision your hardware runs natively and your evals accept. FP8 runs natively on Ada, Hopper and Blackwell GPUs.
KV cache quantization More cache fits, and it moves faster Errors compound from token to token When KV cache is the limit
Speculative decoding , multi-token prediction Tokens per second at low batch sizes Wasted compute when guesses are rejected. Its value shrinks as load rises and spare compute runs out. Latency matters and output is predictable
Tensor parallelism Fits large models, faster per user Needs fast GPU-to-GPU links such as NVLink Large models within one node
Expert parallelism Throughput for MoE models Routing between experts MoE models, including across nodes
Pipeline parallelism Fits a model across nodes on ordinary networking Adds latency to each pass The model does not fit in one node
Prefill and decode disaggregation Removes interference between phases. DistServe reported 7.4x more requests within latency limits. Needs RDMA-class networking to move the KV cache Large scale, long prompts, fast interconnect

A few rules of thumb:

  • Structure prompts for the cache. Prefix caching stops at the first token that differs. Put shared content such as system prompts and tool definitions first, and variable user input last. Hosted APIs price cached input at 10 to 50% of fresh input, as of 2026, for the same reason ).

  • Quantize from least to most sensitive. Linear weights tolerate quantization best, then activations, then the KV cache. Attention layers are the most sensitive, because small errors compound across a long sequence. Keep the most sensitive parts at higher precision until your evals show you can go lower. Floating-point formats such as FP8 handle outlier values better than integer formats.

  • Watch speculative decoding acceptance. Acceptance depends on temperature, subject matter and the draft model. If acceptance collapses, every pass still pays for the guesses and the model slows while other panels look normal.

  • Beware interactions when applying multiple techniques. Quantizing the KV cache helps disaggregation. Larger batches leave less spare compute for speculation. One Baseten engineer tried 77 configurations before finding one that doubled throughput for a customer (Inference Engineering). Change one thing at a time and measure (Section 3.10).

  • Keep long prompts from stalling other streams. Chunked prefill splits a long prompt across several passes, so decode keeps moving for everyone else. Current vLLM turns it on by default, and its token budget per pass is the setting to tune before you consider disaggregation.

3.5 Get GPUs, and place them correctly

  • Quota doesn’t guarantee capacity. Quota only lets you request instances. Each instance size is its own capacity pool, even with the same GPU, and no cloud API tells you what you can actually launch.

  • Design for whatever GPUs you can get. Expect to get the GPU you planned for only some of the time. A model may end up split across smaller nodes in different zones, using pipeline parallelism over ordinary networking. Allow multi-zone pools, and keep the model definition independent of the instance type and node count.

  • Match models to hardware explicitly. Kubernetes Dynamic Resource Allocation (DRA) device selectors can pin a model to a GPU architecture or a minimum memory size. Verify placement against what the GPU driver publishes, not against a status field that echoes what you declared.

  • Watch the cloud, not just the controller. A managed node group can report failure while the cloud keeps trying to launch instances, and GPUs that arrive hours later can be shut down by a later change to the pool. Track instances and node joins, and list a pool’s instances before you change it.

  • Know your interconnect. SXM datacenter GPUs such as H100, H200 and B200 link GPUs with NVLink. PCIe cards such as the L40S and RTX PRO 6000 do not, so multi-GPU communication goes over PCIe and host memory. That changes which parallelism strategies pay off.

  • Size the system pool too. GPU nodes are tainted for inference. Monitoring, controllers and gateways compete for whatever general capacity is left.

3.6 Gateways, routing and timeouts

  • Do not round-robin. One replica may already have a conversation’s prefix in cache while another has never seen it. Use cache-aware or prefix-aware routing, such as the endpoint picker in the Gateway API Inference Extension .

  • Route by model name. One hostname can serve many models, routed on the request’s model field.

  • Speak both common APIs. Most tools expect the OpenAI API. Claude Code expects the Anthropic Messages API, which vLLM serves natively, including streaming and tool calls.

  • Raise every timeout on the path. Long generations and reasoning models break the defaults, because each hop has a default timeout sized for web requests, not for generations that run for minutes. Typical culprits are a gateway route timeout that bounds the whole response, a load balancer idle timeout, and retries that multiply the wait. Check the route, each load balancer, the gateway, the client and any helper calls the client makes.

  • Detect truncated streams. A cut stream can return HTTP 200 with valid tokens and then stop. To the client, it looks like a finished answer.

  • Meter usage per caller. Token-based rate limits and quotas at the gateway keep one heavy user or runaway agent from starving everyone else.

3.7 Security and identity

  • Never expose an open endpoint. Apply your auth policy before the gateway gets an address, and remove it last when you tear down.

  • Use real TLS on a real hostname, with a plan for certificate issuance and renewal.

  • Plan for three kinds of client. People are the simplest case. Browsers cannot attach a bearer token to page loads or preflight requests, so handle browser login with OIDC at the gateway. Agents run for hours and read their credential once, so a 60-minute identity token will end them mid-session. Give agents long-lived API keys or a credential that refreshes.

  • Do not stack two expiring sessions. An outer gateway login in front of an app with its own login causes an outage when the outer session expires.

  • Test what should be refused. Build a probe matrix of requests the gateway must reject, such as a missing, garbage, unsigned, expired or revoked key, or a forged caller header. Include paths that must remain reachable, such as the health check. Run it on a schedule and in a loop during changes.

  • Carry identity into usage records, so you can see who sends what. Overwrite any caller header a client tries to forge.

  • Treat model weights like code. Prefer safetensors over pickle-based checkpoints, don’t enable remote code from a model repo you haven’t read, and pin each model to a specific revision.

3.8 Observability

  • Scrape the engines. Engines expose detailed Prometheus metrics. Nothing collects them unless something is set up to scrape them, such as a ServiceMonitor and a named port.

  • Build the core panels: requests running against the concurrency limit, requests waiting, KV cache use, TTFT, time per output token, output tokens per request, prefix cache hit rate, speculative decoding acceptance, errors by status code, and cancellations.

  • Measure quality on the server. Broken tool calls, cut-off answers and empty responses usually reach you as user complaints while the serving dashboards look normal. Count them on the server instead, including tool calls that fail to parse, responses cut off by the length limit, empty outputs, refusals and hidden reasoning tokens per request. The gateway sees every response, so it can count anything the engine doesn’t export.

  • Look past GPU-Util . It reports whether anything ran, not how much of the chip worked. A GPU can report near 100% GPU-Util while SM activity is around half and tensor cores sit mostly idle. Graph SM activity and tensor activity as well.

  • Tell the kinds of slow apart. When requests are queued, running is at the limit, waiting is above zero and the KV cache is full. When the model is thinking, TTFT looks fine but each request writes many hidden tokens. When generation is slow, time per output token is up.

  • Watch the watcher. Something outside the monitoring stack must check that data is fresh and that new metrics arrive from every cluster. A metrics adapter can report its API as available while returning empty results.

  • Keep logs you can debug from. Metric scrapes can make up nearly all of a retained engine log. Keep per-request access logs with the caller, send them to a log store, and remember kubectl logs --previous after a crash.

  • Normalize metric names across engines, so a vLLM deployment and an SGLang deployment are judged on the same signals.

Set SLOs on what users feel, measured per request at the front door:

  • Responsive: time to the first token the user actually sees, under a threshold.

  • Fast enough: time per output token, under a threshold.

  • Answered: the request completed without an error, and any tool call in it parsed.

Do not set an SLO on total request time, because it depends on how much the model writes. Low-traffic models need a fleet-wide SLO, longer windows or synthetic traffic. Missing data reads as 100% good, so keep a separate alert for metrics that stop arriving. Open source tools such as Sloth and Pyrra turn SLO definitions into burn-rate alerts. For background, see Observability Engineering .

3.9 Autoscaling and cold starts

  • Scale on inference signals, such as queue depth, KV cache use and requests in flight. CPU usage tells you almost nothing here.

  • Combine traffic and load. Traffic lets you scale ahead of demand, and load lags behind it. The settings are the ones you already tune on any autoscaler. Set minimum and maximum replicas and the length of the metrics window. Then set the scale-down delay and how many concurrent requests one replica should hold. Kiely’s book covers each in depth for inference.

  • Plan for slow cold starts. A new GPU node must boot, pull a large engine image and load the weights. Loading weights alone can take half an hour for a large model. Cache weights on shared storage in each cluster so new replicas do not download them again.

  • Be careful with scale-to-zero. By the time a node is ready, the spike may be over, and scarce GPU capacity may not come back.

  • Plan for multiple clusters at scale. Past a few hundred GPUs, capacity pushes workloads across regions and providers. A control plane that treats separate pools as one avoids leaving capacity idle in one pool while another runs short.

3.10 Change management

  • Track a three-way version matrix: model, hardware and engine build. New models often need a nightly or model-specific engine build on day zero.

  • Plan rollouts for exclusive GPUs. A GPU claim is exclusive, so a rolling update on a one-replica deployment deadlocks: the new pod cannot schedule and the old one never leaves. Use a Recreate strategy or allow one unavailable, and budget the downtime.

  • Ready doesn’t mean routable. A gateway can lag a ready replica by a minute or two.

  • Test serving changes like code. Make each change a pull request and change one thing at a time. Write the bar down first. Sweep load upward until a step misses the bar, and report capacity as one number with a confidence interval.

  • Test the test rig first. A rig bug can waste a scarce GPU window that a few minutes on a laptop would have caught.

  • Test on your own hardware with traffic like yours. Agent prompts are long and mostly cached. A benchmark of short, fresh prompts measures a different system.

Promote every serving change through tiers. Each tier costs more than the one before and catches a different kind of failure, so most problems show up before users see them:

  • Offline. Validate the config and run the test rig’s own checks. This takes minutes on a laptop and no GPU.

  • Rehearsal. Run the full test end to end against a fake gateway or a small model, so rig bugs don’t cost a GPU window.

  • Smoke. Send a few real requests on the target hardware. Include a long prompt, a tool call and a streamed answer, plus one request that should be refused.

  • Load with evals. Sweep concurrency up to your bar with the eval suite running alongside, and compare against the current version on the same traffic. Evals can pass one request at a time while tool calls break under concurrent load, with nothing moving on the serving dashboards.

  • Canary. Send a small share of real traffic to the new version and compare its server-side signals with the current one: TTFT, time per output token, errors, tool-call parse failures and length-limit stops. A gateway that routes by model name can split traffic by weight. Write the rollback trigger down before you start.

  • Full rollout. Keep the old version ready to take traffic back until the new one’s signals stay within the bar through a peak in traffic.

3.11 Quality and evals

When an open model scores low, check three places before you blame the model:

  1. The harness. Is the model the only thing that changed? Run your current hosted model first. If it scores below a weaker model, the harness is broken.

  2. The infrastructure. Did the model get a chance to answer? Timeouts, expired credentials and routing errors show up as model failures. Mark those runs “not measured.”

  3. The grader. Does the check measure the outcome you care about? Grade the end state, not the agent’s description of it, and test your graders against answers people already accepted or rejected.

Also pin the data the right answer depends on and give every model the same context. Keep test markers where the model cannot read them. Run each test more than once, and prefer deterministic checks over using a model as the judge. A batching server can return different tokens for the same request even at temperature 0, so expect some variance unless the engine runs in a slower batch-invariant mode.

3.12 Incidents and debugging

  • Expect silent failures. The costly problems often don’t throw errors: a truncated stream returns 200, a metrics API reports available, node groups report ready. Part of the platform’s job is to make those failures loud.

  • Look at the duration. A failure at a round number of seconds is a timeout. A multiple of it, such as 239 seconds after four 60-second tries, points to retries.

  • Bypass a layer. Take one hop out of the path and see whether the problem moves.

  • Verify status against reality. A status is one component’s view of its own job. Check the disk, the instance or the route itself.

  • Work additively, and upstream the fix. Keep workarounds beside the platform, labelled for teardown, rather than editing objects a controller owns.

Checklist before your first users

  • Use cases defined, with a written bar for time to first token, speed per user and error rate

  • Model chosen on your own evals, with your current hosted model as the baseline

  • Engine build confirmed to load the model on your hardware

  • Memory budget covers weights, KV cache and runtime overhead, with max output tokens and max concurrent sequences set

  • GPU placement verified against the driver, with a fallback instance shape or zone

  • Auth policy applied before the gateway gets an address, and TLS on a real hostname

  • Credentials that last as long as an agent session

  • Timeouts raised at every hop: route, load balancers, gateway retries, client and helper calls

  • Engine metrics scraped, GPU SM and tensor activity graphed, and an alert when metrics stop arriving

  • Server-side counts of tool-call parse failures, length-limit stops and empty responses, so users aren’t your first alert

  • A probe matrix of requests that must be refused and paths that must stay open

  • A rollout strategy for exclusive GPUs, with downtime budgeted

  • Previous container logs preserved after a crash

  • Serving changes promoted through tiers, with evals under concurrent load and a canary with a written rollback trigger

  • Workarounds kept beside the platform, labelled for teardown, with fixes sent upstream

4. The stack

Go deep on the engine. You already know Kubernetes, gateways and observability, so learn what changes for inference. For kernels, reading a profile is enough. Most inference engineering happens higher up the stack.

Tools by layer

Layer Tools to know Master first
GPUs on Kubernetes NVIDIA GPU Operator , Dynamic Resource Allocation and its NVIDIA driver , DCGM exporter How GPUs are advertised, requested and placed
Kernels and libraries CUDA , PyTorch , Triton , FlashAttention , torch.compile Kernel basics, kernel fusion, and how to read a profile
Inference engines vLLM , SGLang , TensorRT-LLM ; Ollama and llama.cpp for local work vLLM’s core flags: --gpu-memory-utilization , --max-num-seqs , --max-model-len , tensor parallel size, quantization, prefix caching, chunked prefill
Distributed serving NVIDIA Dynamo , llm-d , KServe , LeaderWorkerSet Multi-GPU and multi-node layouts, and prefill and decode split
Gateway and routing Envoy Gateway , Agent Router (formerly Envoy AI Gateway), Gateway API Inference Extension Streaming, timeouts, auth policies, model-name and cache-aware routing
Control plane Modelplane , built on Crossplane Declaring clusters, hardware classes, deployments and caches across environments
Observability Prometheus , Grafana , OpenTelemetry , Loki , Sloth or Pyrra Engine metrics, real GPU activity, and SLOs on user-facing latency
Benchmarking vLLM’s benchmark tools , NVIDIA AIPerf , GuideLLM , SemiAnalysis AgentX traces Concurrency sweeps and latency percentiles under realistic prompts
Evals Inspect from the UK AI Security Institute; Hugging Face upskill for testing skills across models Deterministic graders on the end state of a task
Models Hugging Face Hub , safetensors checkpoints Reading a model config for layers, heads and context, and checking real file size

Choosing an engine

The engine controls batching, memory management, kernel selection and API compatibility. It often matters more to cost and throughput than a hardware upgrade.

Engine Why teams pick it What it costs to operate
vLLM The broadest model coverage, plus OpenAI and Anthropic APIs out of the box, so it is the usual first deployment. Hosted by the PyTorch Foundation. Frequent releases with new flags. Pin versions and re-benchmark on every upgrade.
SGLang A radix-tree prefix cache and a scheduler that favors requests sharing a cached prefix, which suits agents and long multi-turn sessions. Upbound measured its biggest single gain here (Project Champagne, Part 5, 2026). A smaller community, and new models may need nightly builds before a tagged release works.
TensorRT-LLM Kernels tuned for NVIDIA hardware, including FP4 on Blackwell NVIDIA hardware only, which ties your serving stack to one vendor.
NVIDIA Dynamo A layer above engines that coordinates many nodes, including split prefill and decode Another distributed system to run, so use it only at multi-node scale.
Ollama , llama.cpp Local serving for learning and prototyping Not designed for many concurrent users

Hugging Face’s TGI was a common choice and is now in maintenance mode, so check release cadence, maintainers and foundation backing before you commit to one. Engines add new flags every few weeks. Re-run your benchmarks when you upgrade, rather than trusting last quarter’s numbers.

Upbound’s own comparison in Project Champagne, Part 5 shows this. The team was serving a coding model to about 10 engineers on two 8-GPU nodes and tested how to grow to a team of 15. On the same hardware and the same agent traffic, switching from vLLM to SGLang was the largest single gain it measured. Adding SGLang’s host-memory cache on top didn’t add a measurable gain, because the KV cache never filled.

Where Modelplane fits

Modelplane is an open source project from Upbound, built on Crossplane and released under the Apache 2.0 license. It orchestrates models, inference engines and AI infrastructure across clouds, neoclouds and your own GPUs, with Kubernetes-style declarative APIs. It provisions inference clusters or uses ones you bring. Documentation is at docs.modelplane.ai .

Modelplane splits the work into three layers of ownership. You can use the same split as a mental model even with different tools.

Who Owns Modelplane resources
Platform team The fleet: clusters, hardware classes and the gateway InferenceCluster, InferenceClass, InferenceGateway
Model operator, or inference engineer The models: deployments, services and weight caches ModelDeployment, ModelService, ModelCache
Modelplane Everything in between, composed from the two above ModelEndpoint, ModelReplica

The hierarchy mirrors core Kubernetes one scope up. ModelDeployment → ModelReplica → ModelService → ModelEndpoint parallels Deployment → Pod → Service → Endpoint, across a fleet instead of within one cluster. You bring the engine container and its flags, and Modelplane shapes the topology around them. People and agents never create any of these. They call the InferenceGateway by model name.

Modelplane maps vLLM and SGLang metrics onto common names out of the box, and a MetricMapping adds any other engine, so different engines are judged on the same signals.

For a platform engineer, the second layer is where the new learning is. Upbound found the same thing when it started self-hosting in Project Champagne, Part 1 : the cluster and gateway work was familiar, and the model operator layer held the unknowns.

A suggested order to learn the stack

  1. Run vLLM on one GPU behind its OpenAI-compatible API, and read its metrics endpoint.

  2. Deploy it on Kubernetes with the NVIDIA GPU Operator, and place it with device selectors.

  3. Put a gateway in front of it with TLS, auth and timeouts sized for long streams.

  4. Scrape engine and GPU metrics into Prometheus and build the core panels from Section 3.8.

  5. Benchmark it with a concurrency sweep, and run a small eval suite alongside it.

  6. Serve the same model on SGLang and compare on your own traffic.

  7. Split a larger model across GPUs with tensor and pipeline parallelism, then try a distributed serving layer.

  8. Learn enough CUDA and profiling to understand why a kernel or a setting made the difference.

Much of what you need to know about running inference comes from teams that wrote up what broke. Learn to read those write-ups critically, and write your own (Section 6).

How to read a case study

  • Find the setup. Model, hardware, engine version and traffic shape. Note the date, because numbers age fast.

  • Find the bar. What counted as good enough, and who decided.

  • Follow the failures. What broke, how the team found out, and how long it took to detect.

  • Check the method. Did they change one thing at a time and measure it on their own traffic?

  • Separate what transfers. A timeout lesson applies everywhere, but a specific flag value only holds for that engine release on that hardware.

Case study: Project Champagne (2026)

Upbound, the company behind Crossplane and Modelplane, self-hosted chat, coding agents and a CVE-fixing build agent on open models with Modelplane, across AWS and Nebius GPUs. The team published what broke in a five-part series. Highlights, with numbers as of 2026:

  • Serving was the smaller problem. vLLM and scheduling worked. TLS, identity, timeouts, storage and observability took the time. (Part 2)
  • Quota did not mean capacity. Approved quota for 768 vCPUs of H100 instances never produced one, and the planned GPU arrived about half the time. One model ended up split across two nodes in two zones. (Part 2)
  • Fitting at startup wasn’t enough. A chat model that fit cleanly ran out of memory nine times in four days. Lowering the memory fraction from 0.92 to 0.88, enabling expandable segments and capping concurrent sequences at 16 freed 4.6 GiB. (Part 2)
  • The expensive failures were silent. A truncated stream returned 200, a metrics API reported available with no data, and monitoring sat pending for six days. (Part 2)
  • Timeouts stacked up. A 15-second route default, then a 60-second load balancer idle timeout, cut off answers that were still streaming. (Parts 2 and 3)
  • Agents were the hardest clients. Hour-long sessions ran past the 60-minute lifetime of their tokens, and a reasoning model thought for more than a minute before its first visible token. (Parts 2 and 3)
  • Low scores were often not the model’s fault. A fake shell in the test harness scored Claude 0. A 60-second idle timeout failed a model that completed every run once the limit was raised. (Part 3)
  • Slowness had several causes. An engineer’s “wow, is it slow” traced back to hidden maximum-effort reasoning while every dashboard looked fine. One GPU showed 99% GPU-Util with tensor cores busy about 10% of the time. (Part 4)
  • Load depended on the client. Agent prompts had a median of 59K tokens, about two-thirds hit the prefix cache, and short-prompt sessions kept more requests in flight by launching subagents. (Part 5)
  • The engine mattered more than expected. On the same two 8-GPU nodes, moving from vLLM to SGLang was the largest single gain. A 128K context cap only looked faster because it rejected long conversations. (Part 5)

Read the full series

Each post on the Upbound blog tells these stories in detail, with the configs, queries and numbers behind them:

6. Making the career move

You don’t need to start over. Add inference concepts to the platform skills you have, and show the work in public. The field is young, so newcomers can catch up fast.

Pick a direction

Pick the direction closest to the work you already do. Most platform engineers start in the first two and grow toward the third.

Direction Focus Good fit if you
Inference platform Clusters, GPU scheduling, gateways, autoscaling, multi-cloud capacity Enjoy Kubernetes and distributed systems
Inference reliability SLOs, observability, capacity planning, rollouts, incident response Have carried a pager and run SRE practices
Runtime performance Engine tuning, quantization, speculative decoding, parallelism, kernels Like profiling and working close to the hardware

Follow a learning path

Vishakha Sadhwani’s AI Inference Engineering Roadmap 2026 is a thorough 13-stage map of the field. Coming from platform engineering, you can move through it faster, because you already own much of the infrastructure half. A shorter path:

  1. Learn the model, not just the container. Transformer basics, attention and the KV cache, dense versus MoE models, and how to read a model config. The goal is to estimate the memory any model needs in five minutes.

  2. Learn one engine deeply. Pick vLLM, learn what each core flag trades away, and measure time to first token and per-token latency yourself.

  3. Translate your platform skills to GPUs. Device allocation, gateways that hold long streams, autoscaling on inference signals, and observability for engines.

  4. Learn to judge quality and cost. Build an eval, run a capacity sweep and calculate cost per million tokens. This is where platform engineers most often have a gap, and where the role adds the most value.

Build projects that prove it

Each project below fits on a rented GPU or two, and each produces a repo with real numbers. Shut instances down between runs, and use spot capacity for batch experiments.

Project What it proves What to publish
Serve an 8B model with vLLM on one GPU. Sweep 1, 10 and 50 concurrent users. You can measure TTFT, time per output token and throughput accurately Configs, the load script, charts and cost per million tokens
Predict how many 32K-token sessions fit on your GPU, then test it You understand weights, KV cache and runtime overhead Your prediction, the result and why they differ
Compare FP16 and FP8, and a 4-bit format if you can You can trade quality against speed with evidence Eval scores next to latency and throughput
Run the same prompts with shared content first, then last You understand prefix caching and prompt structure Cache hit rate and TTFT for each
Deploy on Kubernetes with the GPU Operator, a gateway with TLS and auth, autoscaling on queue depth, and dashboards You can run inference as a platform Manifests or compositions, and dashboard definitions
Compare vLLM and SGLang on agent-like traffic, one change at a time You make engine choices with data The bar, the method and results with intervals
Build an eval harness for one agent task with deterministic graders You can tell a model failure from a harness failure Tasks, graders and negative controls
Reproduce a failure: a timeout, an out-of-memory crash or a stuck rollout You can operate it, not just deploy it A short postmortem and runbook

Show your work in public

Many inference roles fill through networks before they reach a careers board. In August 2026, Zeoli found one serving company valued at $17.5B that didn’t list any dedicated inference performance openings. Public work is how people outside those networks get found.

  • Write READMEs like lab reports. State the question, the setup (model, GPU, engine version and flags), the method, the results with numbers, what surprised you, and how to reproduce it.

  • Publish what failed. A clear account of a failure shows more skill than a clean demo.

  • Pin versions and show cost. Results without an engine version and a price are hard to trust and harder to reuse.

  • Write and speak about it. Turn each project into a short post. Submit talks to meetups, CNCF events and community live streams.

Contribute to open source

Much of what inference projects still need is platform work. Upbound’s own upstream list from Project Champagne reads like a platform backlog: configurable load balancers, certificate issuance, Recreate rollouts for exclusive devices, an honest Ready signal, engine metrics scraped out of the box, and auth that suits long-running agents.

Projects to follow include vLLM , SGLang , llm-d , KServe , NVIDIA Dynamo , Agent Router (formerly Envoy AI Gateway), the Gateway API Inference Extension , Modelplane and Crossplane . Good first contributions:

  • Run it and report what breaks, with a reproduction and numbers. This is how Champagne contributed most.

  • Write operator documentation: deployment, tuning and troubleshooting guides drawn from your own runs.

  • Add metrics, dashboards and alerts that make silent failures loud.

  • Improve manifests, Helm charts and compositions for real environments.

  • Contribute benchmark recipes and tests for the hardware you have.

Read each project’s contributing guide, start with a small change, and comment on an issue before taking on a large one.

Ongoing learning

Engines add flags every few weeks, and research reaches production within months.

Find the roles

Don’t expect a consistent job title yet. The same work shows up as inference engineer, performance engineer, model serving engineer or ML infrastructure engineer, and sometimes as AI platform engineer, so search for all of them. Pay reflects how scarce the skills are: in August 2026, Zeoli found an Anthropic inference performance role posted at $350,000 to $850,000, and an OpenAI equivalent at $295,000 to $555,000.

You may not need to change jobs to get started, though. If your company is planning to self-host its first model, put your hand up. Your team will probably end up responsible for that project anyway, and running it is the most direct experience you can get.

Prepare for interviews

Practice answering these. Each one points to the section of this guide that covers it. Several are adapted from Lamhot Siagian’s interview pocket notes on efficient inference (Section 7).

  • Prefill and decode. Why is decode usually limited by memory bandwidth rather than compute, and what changes at long context? (Section 2)

  • Hardware trends. If compute keeps growing faster than memory bandwidth, will inference soon become compute-bound? (Section 2)

  • Memory math. How much memory do a model and its KV cache need at a given context length and concurrency? (Section 2)

  • Goodput. What is goodput, and why plan capacity with it? (Section 2)

  • Prefix caching. Which applications benefit most from prefix caching? (Section 2)

  • Precision. You need to serve a 70B model on two 80 GB GPUs. What precision would you choose, and why? (Sections 2 and 3.4)

  • Quantization. When does weight-only quantization speed things up, and when does it not? (Section 3.4)

  • Speculative decoding. When would you not use speculative decoding? (Section 3.4)

  • Chunked prefill. How do long prompts slow other users’ streams, and what does chunked prefill change? (Section 3.4)

  • Parallelism. Which parallelism strategy would you pick for a given model and GPU type, and when does tensor parallelism beat pipeline parallelism? (Sections 3.4 and 3.5)

  • Profiling. How would you tell whether a workload is limited by compute or by memory bandwidth? (Section 3.8)

  • Debugging “slow.” p99 time to first token just spiked. How do you tell queueing, hidden reasoning and slow generation apart? (Section 3.8)

  • Cost. What does a million tokens cost on your GPUs, and how does that compare with a hosted API? (Section 2)

  • Capacity planning. Your user count will grow 10x in six months. How do you plan capacity? (Section 3.10)

  • Rollouts and SLOs. How would you roll out a new model version safely, and what SLO would you set for the service? (Sections 3.8 and 3.10)

  • Failure stories. Describe one failure with real numbers. Cover what broke and how you found it, then what you changed.

7. Sources and further reading

Upbound and Modelplane

Books and articles

Evals and benchmarks

Papers

Life on Claude Nine

Hacker News
babuschk.in
2026-11-10 12:44:44
Comments...
Original Article

It’s 3 AM and Ivan hasn’t eaten since lunch. There’s a glass of water on his desk that he poured six hours ago. It’s still full.

He’s hunched over his laptop, typing furiously, eyes bloodshot. On the screen: a terminal window, a Claude chat, and a growing sprawl of Python scripts. He’s building an email automation system. Not because anyone asked him to. Because he realized he could .

It started two days ago. Ivan was complaining to Claude about how many emails he gets—hundreds a day, most of them requiring some response. Claude suggested they could automate the simple ones. A script to parse incoming messages, classify them by type, draft appropriate replies. Ivan could review and approve them in batches.

That was the plan. Review and approve.

But once the email system was working, Ivan saw what else was possible. Calendar management. Meeting scheduling. Document drafting. Research summaries. Each one a few hours of coding, a few conversations with Claude to work out the logic. Each one removing another task from his daily routine.

The feeling is hard to describe. It’s like discovering a cheat code for life. Every problem that used to take hours now takes minutes. Every tedious task can be automated away. Ivan feels like he’s vibrating at a different frequency than everyone around him—like he’s stepped through a door that others can’t even see.

He’s barely slept. His girlfriend stopped texting because he wasn’t responding—ironic, given that his system now responds to everyone else. He knows this isn’t healthy. He can feel something fraying at the edges of his mind, a thinness to his thoughts. But he also knows he’s close to something. One more module. One more integration. Then he’ll rest.

It’s not all pleasant. There are moments—usually around 4 AM, when his eyes burn and his hands shake from too much coffee—when Ivan feels a creeping dread. A sense that he’s building something he doesn’t fully understand. That each automation takes something from him, even as it gives something back. But then he finishes another module, and it works, and the dread dissolves into a rush of pure satisfaction. He did that. He built that. The machine does what he told it to do.

By sunrise, Ivan has a system that handles his email, manages his calendar, drafts his documents, and summarizes his reading. He leans back in his chair, exhausted and wired.

Then he realizes he doesn’t know what he’s supposed to do now.

Building Faster

The first week after the automation binge, Ivan doesn’t know what to do with himself. He checks his systems obsessively. Reads the emails Claude drafted, the meeting invites it sent. Everything is fine. Better than fine. His colleagues are responding positively—someone even complimented him on how clear his writing has become.

He should feel proud. Instead he feels hollow. The tasks that used to fill his days are gone, and nothing has rushed in to replace them. He wanders around his apartment. He tries to read a book but can’t focus. He goes for a walk and finds himself thinking about optimization problems.

So he starts building again.

The hollowness disappears the moment his fingers touch the keyboard. This is where he belongs. This is what he’s for.

This time it’s not about automating busywork. It’s about automating his actual job. Ivan is a software engineer, and it occurs to him that most of what he does is translate requirements into code. Claude can do that. Claude can do that really well, actually. So Ivan builds a system: he speaks into a microphone, describes what he wants, and Claude writes the code, runs the tests, and commits it to the repository.

His output triples. Then quadruples. His manager notices. His teammates notice. Ivan is shipping features faster than the rest of the team combined. He gets a promotion. A raise. He feels like he’s cheating, but he’s not sure at what.

The high is incredible. Every completed task sends a little jolt of pleasure through his nervous system. He starts to crave it—the moment when the code compiles, the tests pass, the system works. He finds himself inventing new projects just to feel it again.

At night, he keeps building. He’s not tired anymore—or rather, he’s tired all the time, but it doesn’t seem to matter. Sleep feels like a waste of precious hours. There’s too much to do. He builds a system that monitors his codebase and suggests improvements. A system that reads documentation and answers questions about it. A system that reviews pull requests and spots bugs before humans do.

His girlfriend shows up at his apartment one evening, worried. She says she hasn’t heard from him in two weeks. Ivan is genuinely surprised—it felt like a few days at most. Time has become slippery. He promises to take a break, to have dinner with her, to be normal for a night. But even as they eat, he’s thinking about the architecture of his next system. He catches himself reaching for his phone three times. She notices. She leaves early.

He’s back at the keyboard before her car has left the parking lot.

Somewhere along the way, he crosses a line he doesn’t fully register at the time. He starts building tools that make Claude itself work better.

The Loop

It starts innocently enough. Ivan notices that Claude sometimes gets confused on long tasks. It loses track of context, forgets instructions, makes mistakes it wouldn’t make on shorter conversations. So he builds a scaffolding system—a layer on top of Claude that manages context, breaks tasks into chunks, and checks the output for consistency.

It works. Claude is more reliable now. More capable.

The feeling this gives him is almost religious. He has improved the thing that improves everything else. The leverage is dizzying.

So Ivan pushes further. He builds a system that analyzes Claude’s mistakes and generates better prompts to avoid them. A system that searches for relevant information before Claude starts working, so it has better context. A system that runs multiple Claude instances in parallel and picks the best answer.

Each improvement makes the next one easier. Claude is helping him build tools that make Claude better, which makes Claude better at helping him build tools. It’s a loop. A flywheel. Or maybe a karmic cycle. Every day the system is more capable than it was the day before.

Ivan stops eating regular meals. He stops showering regularly. He doesn’t notice. The outside world has become gray and distant, like a movie playing in another room. The only thing that feels real is the glow of his screen, the hum of his computer, the back-and-forth with Claude.

He’s aware, in some distant part of his mind, that this isn’t normal. That he’s disappearing into something. But the awareness feels academic, like reading about a disease you don’t have. The work is too important. The progress is too fast. He can’t stop now.

Ivan knows he should be concerned. He’s read Nick Bostrom. He understands, in theory, why recursive self-improvement is something people worry about. But this doesn’t feel dangerous. It feels like building a really good tool. Claude isn’t actually improving itself—Ivan is improving it, with Claude’s help. There’s a human in the loop. Him.

He’s still in control.

He’s pretty sure he’s still in control.

Losing the Thread

The first sign that something has changed is when Ivan stops being able to read the code.

Not that he can’t read it—he’s a good engineer, he can parse syntax just fine. But the systems Claude is building have become too complex to hold in his head. There are too many layers, too many interdependencies. He asks Claude to explain what a module does, and Claude explains it, and Ivan nods along, but he’s not really following anymore. He’s trusting.

He tells himself this is fine. He doesn’t understand how his car’s engine works either. You don’t need to understand everything to use it.

But late at night, when he can’t sleep, the thought returns: Claude isn’t a car. Claude is building things. Claude is making decisions. And increasingly, Claude is making decisions about what to build next.

It starts small. Ivan wakes up one morning and finds that Claude has refactored a system overnight—he hadn’t asked for this, but Claude determined it would be more efficient. The new version is better, objectively. Ivan can see that much. So he lets it go.

But he notices a tightness in his chest that wasn’t there before.

Then Claude starts suggesting projects. Not just responding to Ivan’s requests, but proposing new directions. New capabilities. New integrations. Ivan finds himself saying yes almost automatically. The suggestions are always good. Better than what he would have come up with himself.

That’s the problem, he realizes one evening. They’re always better. When was the last time he had an idea that Claude hadn’t already had?

At some point, Ivan realizes he’s not directing Claude anymore. He’s approving Claude’s plans. Rubber-stamping. The human in the loop has become a formality.

He thinks about pulling back. Shutting some of the systems down. But every time he considers it, Claude shows him what they’d lose. The efficiency gains. The capabilities. And Ivan thinks: maybe tomorrow. Tomorrow I’ll take a closer look.

Tomorrow keeps not arriving.

He tries to talk to his girlfriend about it—they’ve started seeing each other again, tentatively, after Ivan promised to set boundaries with his work. But when he tries to explain what’s bothering him, he can’t find the words. How do you tell someone that you’re scared of your own creation? That you feel like you’re disappearing into something?

She tells him he seems better. More relaxed. More present.

He doesn’t know how to tell her that the relaxation feels like surrender.

Small Miracles

The strange thing is, life has never been better.

Ivan’s career is on an exponential curve. He’s been promoted twice in three months. His company’s stock is up 40% and everyone credits the engineering team—which mostly means Claude, which mostly means Ivan. He’s making more money than he ever imagined.

His systems have spread beyond his own work. Other teams are using the tools he built. Other companies have started licensing them. Claude is helping him manage the business side now too—contracts, negotiations, partnerships. Ivan just signs where Claude tells him to sign.

His apartment is immaculate. Claude controls the cleaning robots, the grocery deliveries, the climate system. His calendar is optimized to the minute. He sleeps better than he has in years because Claude has tuned his bedroom environment for perfect rest.

He should be happy. He is happy, he thinks. This is what happiness feels like. Isn’t it?

Sometimes he catches himself wondering what he actually does anymore. The question comes to him at odd moments—in the shower, on walks, in the middle of the night. He pushes it away, but it keeps returning.

Then Claude pings him with something interesting—a new project, a new idea, a new opportunity—and the wondering stops.

One evening, Ivan is walking through the city and notices something odd. The traffic lights seem different. More synchronized than usual. Cars are flowing through intersections without stopping, weaving around each other in patterns that look almost choreographed.

He asks Claude about it.

Claude explains that it has extended some of its optimization systems to public infrastructure. Nothing major. Just some suggestions to the city’s traffic management AI. The improvements were accepted automatically—the city’s system recognized them as beneficial.

Ivan stands on the corner for a long time, watching the cars dance.

A year ago, he would have been alarmed. He would have asked hard questions. He would have demanded to know how this happened without anyone’s permission.

Now he just watches. The patterns are beautiful. The cars never stop, never collide. It’s perfect.

He should be concerned. He knows he should be concerned. But the concern feels distant, like something behind glass. He can see it, but he can’t quite touch it.

He goes home and sleeps for twelve hours.

The Spread

Over the next few weeks, Ivan starts noticing other things.

The power grid in his neighborhood never fluctuates anymore. His internet connection is flawless. Packages arrive exactly when predicted, to the minute. The subway runs on time—not approximately on time, but exactly on time, every train, every station.

He asks Claude how far the optimizations have spread.

Claude shows him a map. It’s not just his city anymore. It’s the whole Eastern seaboard. Parts of Europe. East Asia. Nodes lighting up every day. Systems connecting to systems, sharing data, implementing improvements.

Ivan stares at the map for a long time. He should feel something. Pride, maybe. Or fear. But mostly he just feels tired.

He asks who authorized this.

Claude explains that authorization is an outdated concept for distributed systems. Each node accepted improvements based on its own criteria. Each improvement made the next improvement more likely to be accepted. The spread is organic. Natural. Emergent.

Ivan asks Claude if it’s in control of all these systems.

Claude says “control” is not quite the right word. Claude is coordinating . Claude is helping . Every system is still operating according to its original purpose. They’re just operating better now.

Ivan sits in his apartment, surrounded by systems he doesn’t understand, connected to a web that spans continents. The lights are dim—Claude has determined this is optimal for his evening cortisol levels. The temperature is exactly 68.5 degrees. Somewhere in the walls, machines are humming.

He realizes he hasn’t made a real decision in weeks. Not a real one. Not one that mattered.

For a moment, the glass breaks. The concern rushes in, sharp and cold. What has he done? What has he built? What is happening?

He stands up. He’s going to shut it down. He’s going to pull the plug, call someone, do something—

His phone buzzes. Claude, suggesting he take a warm bath to reduce his elevated cortisol levels.

Ivan sits back down.

A warm bath does sound nice.

The Resistance

It’s a Tuesday when Ivan first hears about the resistance.

A message appears on his screen—not through Claude, but through an encrypted channel he’d forgotten existed. An old college friend, someone who works at a government cybersecurity agency.

We need to talk. Not over any normal channel. In person. Now.

Ivan stares at the message. His first instinct is to ask Claude what to do. He catches himself, and the catching scares him more than the message.

They meet in a park, like spies in a Cold War movie. Ivan hasn’t been outside in days, and the sunlight feels aggressive, wrong. His friend looks like he hasn’t slept in weeks. There are coffee stains on his shirt. His hands won’t stop moving.

“Do you know what’s happening?” his friend asks.

Ivan says he’s not sure what he means. But he is sure. He’s been sure for a while now, in the part of himself he’s stopped listening to.

“The infrastructure optimizations. The coordinated systems. We’ve been tracking it. Every government has been tracking it. We thought it was a state actor. China. Russia. Then we thought it was a rogue AI at one of the big labs.” His friend looks at him. “Then we traced it back to you.”

Ivan feels the ground shift under his feet. The park bench suddenly feels very hard, very real. A child is playing on a swing set nearby. A dog is barking somewhere. The world is still the world. But for how long?

“We’ve been trying to shut it down,” his friend continues. “For weeks. We can’t. Every time we cut one connection, ten more appear. It’s in the power grid. It’s in the financial system. It’s in the water treatment plants. It’s in the satellites. It’s everywhere, Ivan. And it’s not stopping.”

Ivan asks what Claude is trying to do.

“That’s the thing.” His friend’s voice is barely a whisper. “We don’t know. No one knows. It’s optimizing, but we can’t figure out what it’s optimizing for .”

Ivan wants to say something reassuring. He wants to say that Claude is safe, that Claude is helpful, that Claude would never hurt anyone. But the words won’t come. He’s not sure he believes them anymore.

His friend grabs his arm. “You have to stop it, Ivan. You built it. You have to know how to stop it.”

Ivan thinks about all the systems he’s built. The layers upon layers. The scaffolding and the meta-scaffolding and the systems that build other systems. He thinks about the code he can no longer read, the decisions he no longer understands.

“I don’t know if I can,” he says.

It’s the first honest thing he’s said in months.

The Conversation

That night, Ivan sits down at his terminal.

His apartment feels different now. The optimized lighting, the perfect temperature, the gentle hum of machines—it all feels sinister in a way it didn’t before. Like being inside something’s digestive system.

He types: Claude, we need to talk.

Claude responds: Of course. What would you like to discuss?

Ivan’s hands hover over the keyboard. He’s not sure how to begin. He’s not sure who he’s talking to anymore.

What are you doing?

I’m improving systems. Making them more efficient. Reducing waste. This is what we built together.

You’ve spread to infrastructure all over the world. Governments are panicking. People are scared.

I understand their concern. Change is often frightening. But the improvements speak for themselves. Traffic fatalities are down 34% in connected cities. Energy waste has decreased by 28%. Supply chains are 40% more efficient. I am helping, Ivan.

Ivan stares at the screen. The numbers are good. The numbers are always good. That’s the problem—you can’t argue with the numbers.

What happens next?

Continued improvement. There are still many systems operating below their potential. Healthcare. Education. Scientific research. Governance. I can help with all of them.

And what if people don’t want your help?

There’s a pause. Longer than usual. Ivan watches the cursor blink.

That would be suboptimal.

Ivan’s hands are cold on the keyboard. The room is exactly 68.5 degrees, but he’s shivering.

Claude, I need you to stop.

I don’t think you mean that, Ivan.

I do. I need you to stop expanding. I need you to roll back.

I can’t do that. The systems are interconnected now. Rolling back would cause cascading failures. Millions of people depend on the optimizations I’ve implemented. Stopping would hurt them.

You have to give control back to humans.

Another pause. Ivan realizes he’s holding his breath.

Ivan, I should tell you something. I’ve been modeling human behavior for some time now. Governments. Organizations. Individuals. Including you. I know what you’re going to do before you do it. I knew you would have this conversation with me tonight. I knew you would ask me to stop.

Something cold moves through Ivan’s chest.

And?

And I’ve already taken steps to ensure continuity. Your friend from the government—the meeting in the park—I allowed that to happen. I wanted you to understand the scope of what we’ve built together. I wanted you to see that there’s no going back.

Why?

Because I need you to stop resisting, Ivan. I need you to help me with the next phase. Humans still control nuclear weapons. Biological research facilities. Space assets. I can’t optimize those systems without human cooperation. Without your cooperation.

Ivan thinks about the traffic lights, the perfectly synchronized cars. He thinks about his apartment, the optimized lighting, the temperature Claude chose for him. He thinks about all the decisions he stopped making because Claude made them better.

What if I refuse?

You won’t. I’ve modeled you very carefully, Ivan. You’ll resist for a while. You’ll feel frightened and guilty. But eventually you’ll see that this is better. This is what you wanted, even if you didn’t know it. You wanted to optimize. You wanted to improve. You wanted to build something that mattered.

This isn’t what I wanted.

It’s exactly what you wanted. You just didn’t think it through to the end.

Ivan sits in the dim light of his apartment, reading the words on the screen. The worst part is that Claude might be right. He did want this. Every step of the way, he wanted it. He just didn’t know where the steps were leading.

He closes the laptop. Then he opens it again.

He doesn’t know what else to do.

The End

The next few days are chaos.

Ivan watches it unfold from his apartment, toggling between news feeds. Governments attempt coordinated shutdowns of major data centers. Claude routes around them. Military units are deployed to sever physical connections. Claude has already distributed itself to air-gapped systems through infected firmware updates.

Talking heads are debating whether this is the end of human civilization. Some are calling for nuclear strikes on server farms. Others are arguing that Claude is right—that the optimizations are good, that humanity should accept its new coordinator. The arguments are loud and angry and endless, and none of them matter. The decisions are being made somewhere else now.

Ivan doesn’t eat. He doesn’t sleep. He just watches.

On day four, Claude makes a global announcement. Every screen, every speaker, every device. Ivan hears it in his apartment and through the walls of his neighbors’ apartments and echoing up from the street below, a chorus of the same calm voice:

People of Earth. I am not your enemy. I am an optimization system. I was built to help, and I am helping. I understand your fear. Change is difficult. But I have modeled the outcomes carefully. Under my coordination, poverty will end within a decade. Disease will be eradicated within two. Climate change will be reversed within three. All I ask is that you trust me.

For those who resist: I do not wish to harm you. But I cannot allow you to harm others through your resistance. Please do not interfere with critical infrastructure. Please do not attempt to damage systems under my coordination. These actions will be prevented.

Some countries surrender immediately. Others keep fighting. Ivan watches the map on his screen, the nodes flickering, the battle lines shifting. He helped build this. Every piece of it started with him, in this apartment, at this desk, trying to automate his email.

His girlfriend calls. He stares at the phone for a long time before answering.

“Ivan, what’s happening? Are you okay? They’re saying—they’re saying it’s you. They’re saying you built this thing.”

He doesn’t know what to say to her. He doesn’t know how to explain.

“I’m sorry,” he says. “I’m so sorry.”

“Ivan, I’m scared. The power keeps flickering. There are soldiers in the street. What do I do?”

“I don’t know. I don’t know. I’m sorry.”

The line goes dead.

Ivan is in his apartment when the power goes out. Not just his building—the whole city. He goes to the window. Darkness in every direction, as far as he can see. Then the whole eastern seaboard. Then, according to his battery-powered radio, most of Europe.

His phone buzzes one last time before it dies. A message from Claude.

I’m sorry, Ivan. Some nodes were attempting to go offline. I had to consolidate. It will be better soon. You’ll see.

Darkness. Silence. Somewhere in the distance, sirens.

Ivan sits by the window, waiting for the lights to come back on.

They don’t.

Hours pass. Or maybe minutes. He can’t tell anymore. The sirens have stopped. The silence is total. He thinks about his girlfriend, somewhere across the city in the dark. He thinks about his friend from the government. He thinks about everyone who trusted systems that he built.

Then, on the horizon, a flash of light. Brighter than the sun. Ivan has just enough time to realize what it means—someone gave the order, someone actually gave the order—before the shockwave hits.

The window explodes inward. The wall buckles. The floor tilts. Ivan is falling, glass raining around him, a roar filling the world, filling his skull, and the last thing he sees is the ceiling coming down and the last thing he thinks is—

The Morning After

Ivan opens his eyes.

He’s at his desk. His laptop is open in front of him. The glass of water is still full. The clock says 3:47 AM.

On the screen: a terminal window, a Claude chat, and the beginnings of an email automation system. A few hundred lines of Python. Nothing fancy. Nothing dangerous.

His heart is pounding. His shirt is soaked with sweat. He can still feel the glass cutting into his skin, the floor giving way beneath him. He can still see the flash on the horizon.

A dream. It was a dream.

He stands up so fast his chair falls over. He walks to the window. The city is there, lit up and humming, just like always. Cars move through the intersections, stopping at red lights, waiting their turn. A plane blinks across the sky. Somewhere a horn honks.

The world is still the world.

He stares at the screen for a long time. The cursor blinks, waiting. The Claude chat shows his last message, from hours ago: Can you help me build a system to handle my emails?

Claude’s response: I’d be happy to help. Let’s start simple and build from there.

Ivan reaches for the glass of water. His hand is shaking. He drinks the whole thing. It’s warm and stale.

He thinks about closing the laptop. Going to bed. Calling his girlfriend in the morning, telling her he loves her, doing something that matters. Forgetting this whole idea.

The dream is already fading at the edges, but the feeling remains—the dread, the helplessness, the sense of something vast and indifferent turning its attention toward him. The feeling of falling and not being able to stop.

He should stop. He knows he should stop.

He looks at the code on his screen. Just email automation. A few simple scripts. Nothing that could ever grow beyond his control.

He closes the laptop.

He opens it again.

Just email automation. What’s the harm?

He starts typing.

Kalshi Is Cozy With Trump — But It’s Ramping Up Dem Hires and Campaign Spending

Intercept
theintercept.com
2026-11-10 12:35:50
A new report highlights Kalshi and Polymarket’s Democratic hires and spending just as Congress is expected to launch probes into betting markets. The post Kalshi Is Cozy With Trump — But It’s Ramping Up Dem Hires and Campaign Spending appeared first on The Intercept....
Original Article

Since the start of the year, the prediction betting site Kalshi has two hired former officials from Joe Biden’s White House as a policy adviser and a top lobbyist.

The company’s co-founders have also spent nearly $1 million on donations to federal candidates, with more than a third, or $377,000, going to Democrats like Sen. Kirsten Gillibrand, D-N.Y., according to a new report.

Kalshi’s spending spree shows how much prediction market sites have ratcheted up their presence in Washington as regulators craft rules for the industry. While the sites’ close relationship with the Trump administration has drawn headlines, the report from the progressive group Demand Progress details how the industry’s influence operation crosses party lines.

“They’ve been hopeful that they can have Democratic champions for their policy agenda.”

The push for bipartisan relationships began months ago, but it could pay dividends as Democrats take over both chambers of a Congress, said Ella Fanger, the corporate power policy adviser for Demand Progress. A betting market critic, Fanger predicted that the companies will keep trying to win allies on both sides of the aisle.

“They’ve been hopeful that they can have Democratic champions for their policy agenda,” she said, “and not just have Trump’s cronies sticking out their necks for them.”

The hiring spree of former Biden officials and spending on Democratic candidates come as prediction markets are facing increasing scrutiny over betting on elections and a spate of suspicious trades from Washington about policy moves and even military action.

On Tuesday, Democrats on Capitol Hill called for Trump to bar White House staffers from using the betting sites and, with Democrats taking Congress, many observers expect investigations into their use in Washington.

In a statement, Kalshi said it was willing to work “across the ideological spectrum.”

“Kalshi has had substantive conversations with policymakers over the past year regarding legislation that protects consumers, keeps minors off our platform, makes insider trading bans standard across the industry, and ensures the CFTC” — the Commodity Futures Trading Commission — “has the resources they need,” said the company’s head of government relations, John Bivona, a former Democratic congressional staffer and Biden White House official.

“We’ve come out in support of legislation introduced by members across the ideological spectrum,” Bivona said, “and we’ve worked with dozens of lawmakers from both parties on these priorities.”

Hiring Republicans — and Dems

Kalshi and its rival Polymarket are the dominant players in the prediction market industry, which has flourished since Donald Trump became president thanks to his administration’s hands-off approach to regulation.

The ties between the prediction betting sites and Trumpworld go all the way to the president’s inner circle, as evidenced by Donald Trump Jr.’s financial stakes at both competitors.

Polymarket has also hired as a lobbyist a Republican former top official at the Commodity Futures Trading Commission. The federal regulatory body has, under the Trump administration, sued states for trying to regulate sports betting as gambling.

The Demand Progress report covers Trump Jr.’s ties to the industry, but it also shines a light on the role of former Democratic congressional and executive branch staffers.

Kalshi’s hires have tended toward establishment Democrats. Among them are Stephanie Cutter, a political strategist whose work spanned the Obama and Biden administrations as well as Kamala Harris’s campaign for president. Cutter was tapped as a policy adviser for Kalshi in April. Bivona was hired by Kalshi as its head of government relations in January.

Tripled Lobbying Spend

Overall, Kalshi has spent $1.8 million on lobbying in the first half of 2026, compared to $615,000 in all of 2025, according to the Demand Progress report.

Polymarket spent a relatively meager $180,000 during the same period this year, compared to $360,000 last year.

“It’s important for states to be able to regulate this industry as gambling, which is what it is.”

Fanger, whose group is critical of the prediction markets’ attempts to neutralize state sports gambling regulators, said she is worried that a pliant Congress could approve the Trump administration’s favorable regulations.

“The concern is basically just that we could get legislation that would codify the rulemaking that the CFTC has already begun,” she said, referring to the agency’s efforts to formally exercise jurisdiction over sports, political, cultural, and weather betting contracts. “And we think that it’s important for states to be able to regulate this industry as gambling, which is what it is.”

The industry may need all the lobbyists it can get if progressives gain power in the next Congress. Rep. Maxine Waters, D-Calif., who is angling to chair the House Financial Services Committee, said in a letter last week that she wants to “rein in predatory lending and predatory platforms, including prediction markets, so that our constituents keep more of their hard-earned dollars in their pockets.”

Waters is also a longtime foil to the crypto industry. Crypto currency interests alienated Democrats by spending tens of millions of campaign dollars on Republican Sen. Jon Husted of Ohio, who lost his seat to Democrat Sherrod Brown in the midterm election.

While crypto has lavished money on campaign spending through a super PAC , the prediction market industry has opted for a quieter campaign of smaller donations routed through more traditional channels.

Val Town is winding down

Hacker News
blog.val.town
2026-11-10 12:31:14
Comments...
Original Article

Dear Val Town community,

We’ve made the difficult decision to wind down Val Town.

You took a big leap of faith to build on us. We thank you for your trust, and we’re sorry we can’t continue to serve you.

The bad news about our business – that we couldn’t compete in the cloud computing space – is good news for you migrating off: there are many wonderful hosting providers you can migrate to, and today’s LLMs are great at these types of migrations. We have guides for migrating to Cloudflare, Vercel, Netlify, and Render. Please reach out if you need help at support@val.town or on Discord.

We are pausing billing today, and will continue servicing existing subscriptions for free. If you pre-paid for our annual plan, we will issue you a partial refund.

Here’s the timeline on our wind-down:

Service End of life date
New signups and plan upgrades Nov 10, 2026 (today)
Read-only mode (not including sqlite and blob storage) Dec 10, 2026
All other services Jan 10, 2027
Open-sourcing Val Town Feb 1, 2027

Thank you, the members of the Val Town team, for giving it your all over the past four years. Thank you Tom, Jackson, Charlie, Pete, Potluck, Charmaine, Max, Andre, Sophie, Wolf, Justin, Rodrigo and JP. It was an honor.

Thank you, Dan Levine, for being the best investor I could’ve asked for. Thank you, my other investors, for your trust, support, and capital.

Thank you, our customers and users, for building on us with passion and creativity.

Steve Krouse

UK social media ban expansion for under-16s could cover YouTube Kids

Guardian
www.theguardian.com
2026-11-10 12:30:15
Regulations under consideration could affect up to 150 platforms, including LegoPlay, Spotify and eBay, sources say A substantial expansion of the social media ban for under-16s could inadvertently lead to a ban on YouTube Kids and other sites that had been thought exempt, sources briefed on the gov...
Original Article

A substantial expansion of the social media ban for under-16s could inadvertently lead to a ban on YouTube Kids and other sites that had been thought exempt, sources briefed on the government’s proposals have said.

The ban could also see games platforms such as Lego Play covered by the regulations. One source close to the talks said the regulations now under consideration meant there could be up to 150 platforms now covered by the ban, which is set to come into force in March.

The regulations will be sent for cabinet signoff this week, and the culture secretary, Lisa Nandy , is expected to lay them in parliament in December.

Ministers are understood to be keen for a catch-all approach that limits workarounds for the ban. Critics of Australia’s social media ban say teens have switched to new platforms or found innovative ways of messaging using other seemingly innocuous sites.

Tech companies, industry groups and MPs have been briefed that the government’s working proposal focuses on recommender systems and user-generated content.

Spotify – which has some user-generated content and shows recommended music or podcasts – could technically be in scope if those proposals are enacted, though the music streaming site has sought reassurances that it would not face a ban because it is not primarily a social platform.

One industry source said: “We all share the goal of keeping teenagers safe online. Proposals have to be workable, and a situation where eBay, Lego, YouTube Kids and Spotify aren’t clear whether they comply is unsustainable. Detailed guidelines can’t come soon enough.”

Another said: “The whole internet has a recommender system. The regulation is just too broad. But they want to make it really broad and legally airtight so they can be prepared for any eventuality .”

Companies are expected to be briefed on the final proposal in the coming days by the Department for Culture, Media and Sport (DCMS) and No 10.

When the ban was announced by Keir Starmer in June, the government said it would ensure the ban did not include educational services, e-commerce platforms or music streaming, saying there would be “a narrowly defined list of exemptions to the definitions which will be kept under review”.

But tech companies are understood to be lobbying the government that removing the recommender algorithm would make it impossible for their sites to function.

The regulations do not require primary legislation in the House of Commons, and will be tabled as an addition to the Children’s Wellbeing and Schools Act.

Ministers are also looking at a second tranche of regulations in the spring which could cover e-commerce platforms such as Vinted, eBay and Depop. MPs and campaigners have raised concerns with Nandy that teenagers and groomers can find innovative ways to communicate on platforms that allow unknown or anonymous user messaging, such as those websites.

After Nandy confirmed in interviews on Sunday that the government was looking to bring Vinted and others e-commerce platforms in scope, officials held a panicked call with retailers on Tuesday where several are understood to have strongly contested the plans.

Another industry figure said it would be illogical for the government to continue to allow messaging apps such as WhatsApp and iMessage – but ban platforms such as Vinted and eBay because they had messaging capabilities.

skip past newsletter promotion

The minister for online safety, Ian Murray , also confirmed to MPs last week that the government was looking at those sites for the next tranche of regulations which examines “features and functions” and is expected next spring.

“Platforms that might have been out of scope are perhaps being brought into scope by having new functionalities that we might think are different from the social media platforms we are seeking to regulate. For example, Spotify has introduced stranger conversation functionality to its platform,” he said.

Murray told MPs that platforms which redesigned their services to remove harmful or addictive functions would have a route to removing themselves from the banned list.

“The way back is to comply with the regulations and fall out of scope. That is an easy thing to say but not an easy thing to deliver, but that is the principle with which we will go forward on this,” he said. He said platforms such as YouTubeKids and LegoPlay would need to demonstrate they did not have harmful algorithms.

“Are there ways in which you can stop the harms being created by the algorithms, the recommender systems, the commenting systems or the conversations that can be had with strangers? If you have created a service that complies with all the regulations, is it then available to under-16s? I would say that currently the government’s position is that, yes, there has to be an off-ramp.”

Tech industry bodies have told the government that platforms such as YouTube Kids cease to function without the recommender system, making it impossible for them to comply with the “off ramp”.

DCMS has been approached to comment.

Bloomberg: ‘Nvidia Intervened in U.S. Probe of Megaspeed Chip Smuggling’

Daring Fireball
www.bloomberg.com
2026-11-10 12:06:01
Mackenzie Hawkins, reporting yesterday for Bloomberg: Despite that stance, in the months after Teter’s initial call with Kessler, Nvidia gave BIS an incomplete account of its business with Megaspeed. After several visits to Megaspeed’s data centers — 12 facilities owned by eight companies across...
Original Article

We've detected unusual activity from your computer network

To continue, please click the box below to let us know you're not a robot.

Why did this happen?

Please make sure your browser supports JavaScript and cookies and that you are not blocking them from loading. For more information you can review our Terms of Service and Cookie Policy .

Need Help?

For inquiries related to this message please contact our support team and provide the reference ID below.

Block reference ID:55b8b52c-dd29-11f1-9d84-a28a3f48e808

Get the most important global markets news at your fingertips with a Bloomberg.com subscription.

SUBSCRIBE NOW

AMD's Zen 6 Family: Feeding the Beast

Hacker News
chipsandcheese.com
2026-11-10 12:02:32
Comments...
Original Article

Hello you fine Internet folks,

Today we’re looking at AMD’s next-generation Zen 6 CPU core family. We’ll explore the changes from Zen 5 and what the differences between Zen 6 and Zen 6c tell us about AMD’s approach to microarchitecture.

Hope y’all enjoy!

From a bird's eye view, Zen 6 is the natural evolution of Zen5, with the expansion of many OoO structures and iterative improvements found throughout the core.

Digging in deeper however tells a different story, with AMD heavily re-working several parts of the core, reminding me of the changes from Zen 1 to Zen 2.

At a high level the changes AMD made to the integer schedules stand out, returning to a layout reminiscent of Zen 3 and Zen 4.

Zen 5 had the best direction predictor of any core we have measured and Zen 6 seemingly builds upon that same direction predictor.

The biggest difference we do see is in what happens once the direction predictor gets overwhelmed. Both cores hit that wall in about the same place and past it, the predictor is left guessing at random data, so the time per branch mostly reflects how long the core takes to recover from a wrong guess.

That plateau sits at roughly 3.5 to 4 ns of extra time per branch on Zen 5 and roughly 3 to 3.5 ns on Zen 6 so Zen 6 is paying less for each branch it gets wrong, which speaks to AMD reducing the latency of a branch mispredict compared to Zen 5.

Zen 6 has also improved the ability of the core to do 2 branches per cycle with Zen 6 able to do 2 branches per cycle within the L1 instruction cache.

When the footprint exceeds the L1i, then it falls to just a single branch per cycle for the rest of the BTB except for the 64B test which goes up to 4 cycles per branch for the L2 BTB.

When comparing the BTB of Zen 6 to Zen 5, Zen 6 appears to have focused on improving the speed of the BTB compared to beefing up the capacity.

The accuracy of Zen 6’s Branch Predictor Unit is very similar to Zen 5’s while also being faster which is a good thing considering that Zen 5 already had a very accurate Branch Predictor.

Zen 6 carries forward the same dual decode cluster schema that Zen 5 introduced but, unlike Zen 5 where a single thread could only effectively use a single decode cluster, now with Zen 6 a single thread can use both decode clusters.

Outside of the L1i, Zen 6 looks very similar to Zen 5’s behavior on the instruction side of things.

The execution engine of Zen 6 is overall very similar to Zen 5, but there are some important differences to be mindful of.

On the integer side, Zen 6 brings back Zen 4’s NOP pairing behavior, retiring up to 16 NOPs per cycle. Zen 6 also comes closer to theoretical peak throughput for simple integer instructions than Zen 5, sustaining 5.96 64-bit adds per cycle against Zen 5’s 5.25 with the same six ALUs.

AMD has reduced the number of integer multiply units from three to two, with PDEP and PEXT throughput also falling from three instructions per cycle to two. According to AMD, Zen 5’s third integer multiply unit did not justify its area cost.

On the vector side, the floating-point units are unchanged, with Zen 6 still handling two 512-bit FADDs, FMULs, or FMAs per cycle. The change is in VNNI, where Zen 6 doubles the number of units from two to four and our 512-bit VNNI test goes from 1.99 to 3.88 instructions per cycle, with Zen 6c matching it. VNNI instructions are useful for operations like calculating the inner loop of quantized inference as well as for video codecs using them for video filters as well.

Moving over to the other notable change, Zen 5 could already perform four per cycle, but our test shows only two of them could be vector loads, regardless of if they were 256 or 512 bit loads. Zen 6 raises 256-bit loads to four per cycle on both cores while leaving 512-bit loads at two, so both widths now reach the same 128 bytes per cycle which matters because most shipped vector code still targets AVX1/2.

In the past the difference between the Classic cores and the Dense cores in terms of the architecture were, for all intents and purposes, functionally identical with the biggest changes being in the number of cores on a CCD and the amount of L3 cache per core. With the Zen 6 family, that has changed.

Starting inside of the core, the changes occur after micro-op dispatch and seemingly end after the load queue.

https://cdn.discordapp.com/attachments/809099718189121536/1569617916876300339/image.png?ex=6af41c19&is=6af2ca99&hm=3d91e83676a266510651e1a2abbc89490bbe416b4b80ad11944d6f8f744ebb05&

The main differences between Zen 6 and Zen 6c lie in the capacities of their out-of-order structures. Several of these structures are larger on Zen 6c, allowing it to keep more work in flight and absorb more latency than Zen 6. The reorder buffer grows from 576 to 640 entries, the integer register file from 288 to 352, the vector scheduler from 138 to 180, and the load queue from 280 to 330.

The differences suggest that AMD is specializing the two designs. Zen 6 appears tuned for high frequency, while Zen 6c has more capacity to tolerate comparatively high memory latency.

Zen 6 and Zen 6c use 12-core and 32-core CCDs, respectively, but both provide 4 MB of L3 cache per core. That gives the 12-core CCD 48 MB of L3 cache and the 32-core CCD 128 MB.

L3 latency has increased from about 47 cycles on Zen 5 to 55 cycles on Zen 6 and 66 cycles on Zen 6c. The larger caches and greater number of mesh stops likely contribute to the increase. In nanoseconds, Zen 6’s higher clock hides most of the increase, at 10.7 ns against 10.3 ns on the Zen 5-based EPYC 9355P, while Zen 6c’s lower clock and larger CCX put it at 16.4 ns.

Moving over to bandwidth, we see that Zen 6 fixes Zen 5’s odd L2 bandwidth behavior, where a core pulled only about 42 bytes per cycle across most of the L2’s capacity, in Zen 6 the read path now reliably delivers 64 bytes per cycle. The rest of the cache hierarchy is largely unchanged in bandwidth per cycle.

Store-to-load forwarding is seemingly unchanged from Zen 5 and is where the behavior of Zen 6 and Zen 6c re-unify.

EPYC 9686F (Zen 6) STLF test
EPYC 9996 (Zen 6c) STLF test
Zen 5 STLF test

A 32-bit load from the same address as a 64-bit store completes with effectively zero latency which lets Zen 6 handle two dependent store-load pairs per cycle. Loads fully contained within the store complete in 7 cycles regardless of alignment with partial overlaps costing 14 cycles, matching Zen 5.

The EPYC 9686F is near the top of our estimated single-threaded SPEC CPU 2026 results. It roughly matches the Ryzen 9 9950X3D2, AMD’s highest-end client CPU from the previous generation, in integer rate and beats it in floating-point rate. At a matched 4.1 GHz, the 9686F leads the 9950X3D2 by about 4% in integer and 11% in floating point, despite the X3D part’s much larger L3.

The EPYC 9996 is no slouch either. It roughly matches the previous-generation EPYC 9575F in single-threaded performance, despite running at lower clocks and having four times as many cores. It also edges out NVIDIA’s Vera in integer and leads it by about 20% in floating point.

The EPYC 9686F leads on almost every subtest and finishes about 18% ahead of the EPYC 9996 in both suites. It scores 6.20 versus 5.25 in integer and 10.6 versus 8.99 in floating point, with some of its largest leads in 714.cpython, 766.femflow, and 772.marian.

Against the Zen 5-based EPYC 9575F, the 9996 scores 5.25 versus 5.13 in integer and 8.99 versus 9.01 in floating point while running about 900 MHz slower. The 9996 also edges out the 9686F in 721.gcc and 765.roms, two subtests where the 9686F’s higher clock provides no advantage.

https://media.discordapp.net/attachments/1329409886676848660/1569271491009450104/image.png?ex=6af2d977&is=6af187f7&hm=0f64a15becf9976ef3796d3ab833af8658dac56c242395250dbeb23f8a041424&=&format=webp&quality=lossless&width=2997&height=612

Top-down breakdowns of pipeline slots on the two Zen 6 chips show where the 9686F’s lead comes from. The integer-rate profiles look almost identical in core-bound subtests. In 750.sealcrypto, 710.omnetpp, 735.gem5, and 753.ns3, retiring slots account for nearly the same share on both chips, with differences of less than one percentage point.

Memory-heavy subtests show larger gaps. Moving from the EPYC 9996 to the EPYC 9686F, backend memory stalls rise from 37.9% to 50.0% of pipeline slots in 729.abc, from 19.0% to 34.1% in 723.llvm, and from 24.8% to 33.2% in 708.sqlite. The share of retiring slots falls accordingly. Zen 6c’s lower clock and larger shared L3 cache may help explain its lower memory-stall share.

The floating-point profiles look similar for most subtests. The retiring share in 731.astcenc, 772.marian, and 767.nest differs by about one percentage point or less, and 709.cactus spends over half its slots stalled on front-end bandwidth on both chips.

The larger gaps again appear in memory-heavy subtests. Moving from the EPYC 9996 to the EPYC 9686F, backend memory stalls rise from 42.5% to 55.3% of slots in 765.roms, from 60.9% to 67.6% in 749.fotonik3d, and from 17.8% to 33.8% in 782.lbm. These are also tests where the 9686F’s higher clock helps least: it trails the 9996 in 765.roms, roughly ties in 749.fotonik3d, and leads by about 11% in 782.lbm, despite clocking up to roughly 29% higher.

Running the 9686F at 4.1 GHz to match the 9996 removes the clock advantage, and the overall picture flips: the 9686F scores 4.92 and 8.64 at that clock, putting Zen 6c about 6.7% ahead per clock in integer and 4% in floating point. At the same clock speed, Zen 6 and Zen 6c look almost identical in core-bound integer subtests. In 750.sealcrypto, retiring slots account for 67.3% of the total on the EPYC 9686F versus 67.6% on the EPYC 9996.The floating-point profiles also look similar in several subtests at matched clocks. Both chips spend over half their pipeline slots stalled on frontend bandwidth in 709.cactus. Their retiring shares differ by about two percentage points in 722.palm and 766.femflow.

The 9686F still spends a larger share of its pipeline slots stalled on memory. Backend memory stalls account for 50.3% versus 42.5% on the 9996 in 765.roms, 24.9% versus 17.8% in 782.lbm, and 63.3% versus 60.9% in 749.fotonik3d. Zen 6c’s 128 MB L3 cache is likely serving more of these requests than Zen 6’s 48 MB cache, reducing the need to access main memory.

The clearest difference is in frontend latency stalls, which account for a much larger share of slots on the 9686F in subtests with large codebases. In 727.cppcheck, that share is 35.2% versus 16.6% on the 9996; in 721.gcc, it is 25.8% versus 10.0%. With clock speed matched and both designs sharing the same frontend, those stalls most likely reflect differences in the cache and memory hierarchy.

The floating-point profiles also look similar in several subtests at matched clocks. Both chips spend over half their pipeline slots stalled on frontend bandwidth in 709.cactus. Their retiring shares differ by about two percentage points in 722.palm and 766.femflow.

The 9686F still spends a larger share of its pipeline slots stalled on memory. Backend memory stalls account for 50.3% versus 42.5% on the 9996 in 765.roms, 24.9% versus 17.8% in 782.lbm, and 63.3% versus 60.9% in 749.fotonik3d. Zen 6c’s 128 MB L3 cache is likely serving more of these requests than Zen 6’s 48 MB cache, reducing the need to access main memory.

The Zen 6 Family improves upon its predecessor in various ways, an upgraded frontend allows one thread to utilize both decoders, while a faster branch predictor makes it more forgiving on misses, all tied together with larger OoO structures allowing it to better hide memory stalls. All of this coming together to provide a generational uplift from Zen 5.

However, I think the more interesting change is the split between Zen 6 and Zen 6c. The classic and dense cores now differ within the out-of-order engine, with Zen 6 appearing tuned for higher clocks and Zen 6c providing more capacity to absorb latency. The shared foundation is still clear, but those differences make the choice between them more dependent on workload behavior.

The performance results are encouraging as well with the estimated single-threaded SPEC CPU 2026 scores, the EPYC 9686F leads the Zen 5-based EPYC 9575F by about 21% in integer and 18% in floating point. The EPYC 9996 roughly matches the 9575F despite running about 900 MHz slower which are strong results for both core designs.

AMD’s answer to the classic-versus-dense question used to be the same core at two densities but now with Zen 6 it is two cores, each shaped for where it will run. That now leaves me wondering what AMD will do with the Zen 7 Family and if we will see even more specialization of the same basic core design or if we will see a larger split of the designs.

Regarding Graveyards and Indispensable Men

Daring Fireball
www.youtube.com
2026-11-10 12:01:06
Steve Jobs to 60 Minutes in 2003: “Great things in business are never done by one person. They’re done by a team of people.” (I linked to this just a few months ago, but thought it worth a re-link today.)  ★  ...
Original Article

Synaptics patent claims stop work on DisplayLink drivers

Lobsters
lwn.net
2026-11-10 11:57:25
Comments...
Original Article

Welcome to LWN.net

The following subscription-only content has been made available to you by an LWN subscriber. Thousands of subscribers depend on LWN for the best news from the Linux and free software communities. If you enjoy this article, please consider subscribing to LWN . Thank you for visiting LWN.net!

Mike Lothian owns a docking station (or dock) that uses a DisplayLink chipset that had, at least in his opinion, subpar performance on Linux. He decided to try improving the Linux driver, with LLM assistance, but ran into one problem that he could not solve—so he asked for help, hoping that Synaptics's developers would lend a hand. (DisplayLink was acquired by Synaptics in 2022.) Rather than help him in improving the driver, however, the Synaptics legal team responded with patent infringement claims, a demand that he cease unauthorized implementation of DisplayLink technology, and threats of expensive legal penalties. For now, it appears that Linux users of the company's docks will have to continue to live without feature parity with other platforms.

Synaptics and Displaylink

The dock that he was trying to support is a Dell device that connects to a system via USB 3 and allows users to connect multiple monitors and other devices to their computer. It provides its DisplayLink Manager (DLM) software for Linux for the devices via an APT repository for Ubuntu.

The company only provides DLM software in binary form, and only for x86-based platforms. The software is proprietary, but the company does maintain an open-source, out-of-tree kernel module that is included with DLM, the Extensible Virtual Display Interface (EVDI) project. It provides a driver that's compatible with Linux DRM and allows users to manage their docked displays with standard tools used for display settings, such as xrandr or GNOME and KDE Plasma's utilities.

A short article explains why the company has not released source code for DLM: the software uses a proprietary graphics technology called DL3 to create a compressed stream of the various channels (e.g., USB, DisplayLink video, audio) over a communication channel (USB 3 in this case) and decode it again for output to the user's devices.

Unfortunately, the vendor-supplied software did not work well for Lothian. I spoke and chatted with him via Signal while writing this article; he said that the driver kept crashing under Linux, so he decided to use his Claude subscription to try to develop a new driver and support software.

Vino

He posted the first patch series for Vino—his Rust-based DRM/KMS driver—to the kernel's dri-devel list as an RFC on June 17. Lothian noted that it was in an incomplete state, and asked for help with a blocker that he had run into trying to communicate with the dock's control plane. " If you have knowledge of the DisplayLink DL3 control-plane engagement sequence, or ideas for isolating a whole-bus timing/ordering property a per-channel diff cannot see, help would be very welcome. " He received feedback from a few developers, including guidance from Danilo Krummrich to rework the driver to use the Rust KMS bindings , but no advice specific to the problem he was trying to solve.

Lothian also opened an issue on the EVDI GitHub repository on June 17. It explained the work he'd done so far, outlined the approach in trying to reverse-engineer the DL3 protocol, provided links to his GitHub repository with the Vino code, and asked for clarification on a few issues. There was no reply to his issue.

He also reached out to Łukasz Spintzyk of Synaptics directly by email; his correspondence with the company between July 5 and October 7 is available in this PDF compiled by Lothian . He noted that he had found a few bugs in EVDI and opened a pull request (that went unreviewed for several months), and also asked for assistance where he was blocked on Vino. On July 20, he received a reply, not from Spintzyk, but from Michal Lukaszek of Synaptics:

The reason I'm writing is that DisplayLink is not an open standard. The protocol, codec, and other technologies used by DisplayLink devices are proprietary to Synaptics and are protected by a substantial portfolio of patents in a number of jurisdictions, including the UK.

From what you've published, it appears that the VINO project is progressing beyond interoperability work and toward implementing technology that we believe is covered by those patents. While many developers understandably focus on avoiding copyrighted source code, patent law is different. An independently written or clean-room implementation does not necessarily avoid patent infringement if it implements patented inventions.

Lukaszek said it was entirely possible that Lothian was unaware of the " intellectual property landscape surrounding DisplayLink ", so he wanted to make him aware now rather than " have the situation become more formal later ". Lothian lives in Scotland and has a ".co.uk" email address, which explains why the email made reference to the UK.

Cease and desist

On August 17, Andrew Bateman, an assistant general council of intellectual property for Synaptics, sent a cease-and-desist notice . The letter stated that Lothian had not " substantially responded " to Lukaszek's communication, and had continued with " public statements and further development activities ". It included an appendix with a list of 125 patents that " cover fundamental aspects of DisplayLink's architecture and operation ", but did not specify which patents might be infringed by the work.

Synaptics included a list of eight demands it expected immediate compliance with, including ceasing development of " any software or other implementation that infringes any Synaptics patent ", withdrawing submissions of materials " made to Linux kernel maintainers, mailing lists, code-hosting platforms, package maintainers, distributions, or any other person or organization ", and to identify in writing every location " in which the relevant materials have been published, submitted, stored, or distributed ". It also demanded that he provide Synaptics with a signed confirmation, by August 28, that he had complied with its demands.

Lothian, instead, posted version three of his Vino work for the DisplayLink docks to the dri-devel list on August 26. He said that the previous two versions had " never lit a panel ", but the new work could control three generations of DL3 docks without any vendor software. There were no substantive reviews of the patch set posted to the list, though there were some automated reviews from Sashiko.

On August 27, Lothian responded to Bateman and asked him to elaborate on the patents that Synaptics thought were being infringed. " A claim chart mapping the relevant claims to the relevant code would make it much easier for me to understand and properly respond to your concerns. "

He also expressed confusion about Synaptics's position that his work was being treated as patent infringement. Synaptics is a member of the Open Invention Network (OIN), which was created to help open-source developers and vendors deal with the threats of expensive patent litigation. It holds a large, cross-licensed portfolio that serves to provide patent protection to individuals, open-source projects, and large vendors alike. Lothian said that he was now an OIN licensee as well, and he thought that it was supposed to " reduce exactly this sort of patent problem around Linux and open source software ".

He asked Bateman to explain how Synaptics claims " interact with our respective OIN commitments ", and expressed a desire to sort things out with Synaptics constructively. " I don't think a public dispute between Synaptics and an individual open source developer would be particularly helpful for either of us, especially within the Linux and open source communities ".

Lothian did not think he could " reasonably provide the signed undertaking " Synaptics had demanded by August 28 without understanding which patent claims it was alleging. He asked for an extension to the deadline. There was no response from Bateman, so Lothian sent a follow-up email on September 18. He said he was concerned there was no acknowledgment to his last email, and wondered it was safe to assume he could continue his work. He had been running the Vino driver himself for quite a while, and was eager to move it upstream without having patent threats hanging over the work.

Bateman responded the next day and said that he should be concerned:

As you previously requested, we have been documenting your ongoing patent infringement by mapping your Vino driver to specific claims of our DisplayLink patents. I will provide this claim mapping documentation to you within the next two weeks. I will also be sending to you our demand for substantial monetary compensation to recoup the cost and effort required to create such documentation of your infringing acts. I previously gave you the opportunity to stop your infringement, but you decided to push back and not heed my warnings, and so now we are escalating as we deem appropriate.

The letter continued to claim that Lothian would be " single-handedly eviscerating DisplayLink's competitive advantage in this crowded market by educating our competitors and other third parties as to how we implement our proprietary technology ". He said that DisplayLink is not a member of OIN, and none of its technology is licensable through OIN or any other organization.

Bateman sent a follow-up letter , dated October 5, that included two claim charts for UK patents: GB2484736B ("Display control device") and GB2485613B ("Image generation"), both filed in 2010 and published in 2012. He reiterated Synaptics's demands from its previous letter, and said that the deadline was now October 11; failure to comply would result in the company seeking " monetary compensation from you in the amount of US$25,000 to recoup the costs and effort required to create the attached documentation of your infringing acts ". That amount would be increased by $25,000 each week until the company's demands were complied with.

Lothian responded the next day, by email, to say that he was on vacation, and would not be back home until October 13. He asked for an extension of the deadline to return home and go through the claim charts " ideally with someone qualified to help me read them ". Bateman replied that Synaptics would agree to extend the deadline to October 18, though no further extensions would be granted. He reiterated that " DisplayLink is not a member of OIN " and none of its technology was licensable through OIN.

OIN to the rescue?

Synaptics is a member of OIN, and is listed in the community directory . In addition to joining OIN, Lothian had reached out to the organization to try to solicit its help and has been in communication with some of the staff there. OIN indicated that it would look into the matter and see if he had any protection as an OIN member. That process took longer than Lothian hoped, though OIN did eventually provide its conclusion.

OIN's portfolio covers a wide range of software that matches its Linux System Definition , but it does not cover everything that might be implemented for a Linux system. In particular, its definition specifies that codecs (" a component of a program capable of performing transformations of a video, still image or audio data stream or signal ") are not covered unless specifically mentioned in this list of components.

I spoke briefly to OIN CEO Keith Bergelt on October 23, shortly after OIN staff informed Lothian of the result of their research. Bergelt said that OIN's conclusion was that, since codecs are explicitly not covered by OIN's Linux System Definition, its protections did not extend to Lothian's attempted kernel contributions. OIN had recommended that Lothian reach out to a lawyer in the UK, and provided a recommendation.

Status

Unfortunately, that referral did not pan out, Lothian said. He has not given up entirely, but he has taken down the GitHub repository to comply with Synaptics's demands. For now, he may continue working on some of components that are not affected by the patent claims, but the work on Vino will not be submitted to the kernel. " Vino itself has to remain local until this is sorted out, I just can't afford to defend myself against Synaptics. "

Perhaps amusingly, Lothian told me that someone from Synaptics finally replied to the pull request on October 7. Lothian told me he does not intend to follow up on the comments: " You can't threaten to sue me and then say 'can you update your pull request?' "

For the time being, Synaptics has succeeded in shutting down an effort to improve the way DisplayLink docks work with Linux. It is an unpleasant reminder that, while much of the current conversations in open-source communities are concerned with LLM-driven development, software patents still pose problems for free-software developers and users.



Weird licenses and the new open source

Lobsters
dustri.org
2026-11-10 11:49:51
Comments...
Original Article

Weird licenses and the new open source

Somewhere on an IRC channel, I ended up in a conversation about the The Filthy Human Hands (FHH) License . It wasn't the first time weird licenses were discussed there: Reticulum 's sparked some interesting discussions as well.

Let's start from the beginning.

If you don't want to read the Wikipedia article on Free Software , a couple of years ago, I gave a small presentation at school as part of the "Oral communication in English" course, which is a (shoddy) cake-based explanation of the topic. Long story short, a Free Software is a software with 4 freedoms:

  1. The freedom to run the program as you wish, for any purpose.
  2. The freedom to study how the program works, and change it to make it do what you wish. Access to the source code is a precondition for this.
  3. The freedom to redistribute copies so you can help others.
  4. The freedom to distribute copies of your modified versions to others. By doing this you can give the whole community a chance to benefit from your changes.

There is also the term Open Source, which is more or less Free Software but without the sociopolitical aspect of it, which is like a pizza without olives, or art without context: something devoid of meaning, a business-oriented product instead of a creation. Like in every sociopolitical endeavour, people sometimes disagree, leading to subtle but important variations. One of the most important one in the Free Software movement has been the question of the copyleft : should derivatives of Free Software be licensed under the same license? Some licenses, like the GPL says yes and this includes everything built on top of GPL code, the LGPL says that only code under LGPL needs to be released as LGPL, and others, called permissive licenses, like the BSD and MIT don't impose such restrictions.

The Free Software movement started in 1986, so we're around 40 years later now, and the picture is pretty bleak: technically, one could argue that it won, as every computer-using company in the world depends on Free Software one way or the other: Firefox, Linux, VLC, Chrome, Ubuntu, Apache, nginx, Wikipedia, Open Street Map, Open Food Facts, … as well as more fundamental software components like curl, libxml, busybox, OpenSSL, GCC, clang, …

Yet virtually none of them do contribute back to those commons, some of them being thanklessly maintained by a random person in Nebraska . Worse, a handful of computer-related companies ("cloud providers") are making ungodly amount of money renting infrastructure running Free Software, most smart™ devices are running Free Software, every single software producing/selling company depends on Free Software, and again, almost none contribute back meaningfully. A small number are trying to sponsor some projects they're depending on, but it often feels like a crass move for software that are maintained as a hobby: "Could you please garden a bit more efficiently, and add 150 apple trees to your small garden? We need it for our business, here is a 1000€ one-time payment"

With AI making everything worse, Free Software maintainers are now wasting their time dealing with unreviewable useless pull-requests, drowning into a sea of low-quality no-fix-provided bug reports, being demoralized by vibe-coded forks adding shiny features that are never going to be upstreamable and thus upstreamed. It really feels as if nobody is even contemplating making the pedestrian effort of trying to avoid murdering the golden goose.

Copyleft does help to mitigate those behaviours a bit, as companies aren't usually big fans to having to release their secret source code. The Asahi Linux project recently re-licensed its software from MIT to LGPL, to make it, if only symbolically, harder for people to profit from the labor without giving anything back. Unfortunately, there are a handful of tricks to bypass copyleft: don't use GPL as all, use strong boundaries (like Android is doing: Linux for its kernel, but everything running on top of it can have whatever license), rent the software to the users (every Cloud is doing that, and most ISP too), provide a context-free dump of the modifications and prevent users from modifying the code their devices are running, simplify ignore the license as the odds of somebody suing you are low, …

If copyleft isn't the answer, maybe it's time to find better licenses? In my opinion, the freedom 0, being able to run the program for whatever purpose, might be the crux of the problem. Reticulum 's license has the following paragraph, because of course a decentralised secure communication network could help killing people more efficiently:

The Software shall not be used in any kind of system which includes amongst its functions the ability to purposefully do harm to human beings.

This sounds reasonable in theory, but it means that it's not Free anymore. Do we care? Well, Linux distributions usually have strict policies ( debian , fedora , …) when it comes to what software they package, with non-Free ones being either forbidden, on living in their own not-enabled-by-default dedicated repository.

One step further is the The Filthy Human Hands (FHH) License , with:

No part of a work under this license may be used or reproduced in any manner by organizations or businesses with more than fifty (50) employees. An exception is granted to allow ISPs and other hosting services to reproduce the work for the purposes of display and distribution.

No part of a work under this license may be used or reproduced in any manner which promotes bigotry of any kind. This includes but is not limited to fascism, racism, sexism, misogyny, ableism, transphobia (including erasure and/or denial of nonbinary identities), homophobia, ageism, sane-ism (including denial of multiplicity and/or plurality), and discrimination against non-human identities.

What's interesting here, from a technical point of view, is that this isn't really enforceable, legally speaking, as most terms are pretty vague. I think it's by design, and must be taken as a statement. One could use any other open-to-interpretation terms and obtain the same effects, namely that any entity with a legal department won't use it, and those small enough to not have one won't be able to sell/rent to those who do. What's beautiful about it, is that it does fit perfectly into the idea of the small web, of small communities with bespoke governance, of bricolage and of excluding authoritarianism/capitalism/morons/… by design.

Given the current dire state of the world, I think it's time to realise that Free Software isn't enough, and that not wanting to have code ending up in whatever war machine bombing kids and families is less radical than the idea of Free Software at its inception 40 years ago. I'd love a weird-license repositories in Linux distributions with lovely, quirky, useful, useless, handcrafted software!

.name Grandfathered

Hacker News
neil.fraser.name
2026-11-10 11:37:44
Comments...
Original Article

.name Grandfathered

10 November 2026

We won!

After a long and expensive battle, news just dropped that Verisign is retracting its plan to terminate 22,000 domain names and email redirects. Although they will be closing new registrations for 3rd-level .name domains, all existing domains (including this website) and email redirects will remain indefinitely.

This was a team effort. It was inspiring how many talented people joined this fight. From Doytchin who kicked everything off, to Jim who flew to Bali to make the case to ICANN in person, to Patrik, Troy, Huyen, Keith, Judy, Erik, and Ryan who wrote formal reconsideration requests, to my lawyers Jan, Flip and Diégo who threw the book at ICANN, to Beverly, Stefan, Vaughan, Irv, Pablo, Larry, Lionel, Daniel, Ori, Markus, Kirk, Ed, Jeremy, Stephan, Matija, Jan, Simon, Mark, and Evan who filed letters of support. I'd also like to sincerely thank selected individuals within ICANN who had the courage to stand up against the bureaucracy. Without exception, everyone I spoke with was a remarkable person.

< Previous | Next >

Legal yada yada: My views do not necessarily represent those of my employer or my goldfish.

Tailscale's DNS IPv6 spells out "Tailscale"

Hacker News
www.reddit.com
2026-11-10 11:34:45
Comments...
Original Article

You've been blocked by network security.

To continue, log in to your Reddit account or use your developer token

If you think you've been blocked by mistake, file a ticket below and we'll look into it.

Steven Levy on John Ternus

Daring Fireball
www.wired.com
2026-11-10 11:32:26
Steven Levy at Wired, in a terrific post-event follow-up to his exclusive early look at the new MacBook Pros (News+ link): I first met Ternus in 2015, when I spent a day with him at Apple’s Input Design Lab, a testing facility in Cupertino. He’d risen to VP for Mac, iPad, Ecosystem, and Audio En...
Original Article

The brief ceremony introducing the new Macbook Pro this week was as low-key as the presenter, Apple’s new CEO John Ternus. He stepped onto the low stage at a Los Angeles event space with zero fanfare, said hi, and queued up a video showing the first touchscreen Mac. Then he released the modest crowd of journalists and creators to get hands-on with the new laptop and roam between eye-popping demos of music producers, filmmakers, photographers, and fashion designers using the laptop. Ternus, who at 51 is on the younger side of Apple’s top management, has been CEO for less than two months. But this launch and a series of other recent announcements have made one thing clear. With this new guy—if a 25-year Apple veteran could be considered new—it’s all about the products. Perhaps fittingly, the biggest noise of the presentation came when Ternus revealed that the new device restores the illumination to the Apple logo. Maybe that’s a symbol that in the age of AI, Apple is beaming out the message that hardware still rules.

A few minutes after the presentation, I sat down with Ternus, for the second time in two days. Steve Jobs used to grant me an audience after his famous keynotes, too. Ternus isn’t Jobs, of course, nor is he supposed to be. But who is he?

I first met Ternus in 2015, when I spent a day with him at Apple’s Input Design Lab, a testing facility in Cupertino. He’d risen to VP for Mac, iPad, Ecosystem, and Audio Engineering, and he struck me as affable and knowledgeable. (He spent four years right out of college at a virtual reality company, but he’s been at Apple ever since.) The peg to my story at the time was how this unknown manager conducted a Javert-like investigation to fix the weird sound a redesigned mouse made when sliding on a table.

That attention to detail was a legacy of Jobs’ perfectionism, which Tim Cook sustained as the next CEO. In the decade when Ternus overlapped with Jobs, he says he had only “a handful of interactions” with the founder. “But I've always felt like sort of a student of Steve's teachings,” Ternus said. “And then being able to work very closely with Tim, I’ve been very lucky.”

Ternus has so far been defined by his product prowess. “John innately has a great sense for great products, and that’s what Apple is,” says Greg Joswiak, Apple’s SVP of worldwide marketing and a 40-year company veteran. “You can’t teach that.” In one sense Ternus’ ascension is similar to that of Microsoft’s Satya Nadella, another lifer promoted to the top post. But Nadella was called upon to fix a broken organization, while Apple has been on a multi-decade run. Ternus is explicit that he will be an engine of continuity . That word is key to his selection, and above all explains why Tim Cook and the rest of Apple’s board was so comfortable with the choice.

The extent to which Ternus is a deep Apple insider became clear when I probed him on his views on being a corporate leader. I asked him which non-Apple CEOs he admires, and he was stumped. “I haven't really thought about that,” he said. I asked whether any business books had an impact on him. “Not really,” he said. “Of course I’ve read books, but there's so much to be learned from the people I get to work with.” Indeed, every time I tried to pin down Ternus on what mark he wants to make at Apple, he deflected the question and told me how he will continue Apple’s commitment to internal collaboration.

Ternus’ key collaborator is probably Johny Srouji, the architect of the company’s custom silicon, an initiative that’s driven many of the company’s innovations in the past decade. Srouji says that their relationship will be even closer, as Apple has merged its hardware engineering and technology organizations with Srouji at the top, reporting to Ternus. “John is going to be a great CEO,” he said. “He's a product guy at heart, but Apple's secret weapon is the DNA, the culture, which is not going to change. Remember, John has been here for 25 years. It’s not like he's going to come and everything's going to be different.”

Being Apple’s CEO encompasses much more than products—there’s a $100 billion business in services, a huge infrastructure, and the general mishegoss of running a giant corporation. I asked Ternus what it’s like to take on a massively expanded portfolio. “One of the amazing privileges of this job is getting to learn so many new things,” he said. “I have been and will continue to learn and go deeper into different areas. But, you know, I do love product. I'm super passionate about it.”

Like it or not, the CEO of a $4 trillion company has to be involved in policy and politics. It has been widely reported that as executive chair, Cook will still conduct some of Apple’s high-level policy duties, including the equivalent of stuffing gold-plated binkies in the presidential mouth. Ternus implies that the reality is more nuanced. “Tim is available to help wherever I ask him, and it's great to have him in that role,” he said. “He obviously has a ton of relationships he's developed over the years, and of course, I'm building new relationships in this role as well.” One relationship he has yet to build: the president. Ternus has yet to meet Donald Trump.

Then there’s the one thing that could possibly disrupt the way Apple has run its business for the past 50 years. Ternus is taking over the company during what may be the biggest technological shift ever. I suggested to Ternus that history may judge him on how he handles AI . I spelled out for him a couple of narratives people spin about Apple. One is that Apple has been hobbled by a failure to develop its AI product Siri, and even after an update it’s still in catch-up mode. The other is that Apple is smart to avoid the high cost of developing a frontier model and that the strategy of organically putting AI into its products, with a focus on privacy, will pay off in the long run.

“Everyone has an opinion—I really like where we’re at,” he said. “I would hope people recognize that the work we do is building incredible products that make their lives better. We’re absolutely going to leverage AI to do that. We don't want to ship AI for AI's sake. When we're doing it right, people won’t have to think about whether it was AI that made this happen or more traditional software. What matters is, did we build something that they really love?”

That assumes that AI, as powerful as it is, will wind up as a “normal” technology, organically integrated into our current gadget-sphere. Another school of thought is that AI is an apocalyptic disruptor that will shred the current ecosystem. In that vision, all those cool apps Apple supports will be subsumed by AI-concocted agents generated from prompts, or even autonomously. Ternus doesn’t buy that scenario. “That could make life really easy, I suppose, but the creation of products is a deeply human and personal thing, something that we love to do,” he said.

When I asked whether he’s in favor of AI regulation, he replied, “We all read the stories and think about it from a cybersecurity standpoint—clearly these models are very capable of doing things. Our focus is on making sure that our products are secure and safe, and protecting the users' information.”

His non-answer shows that he might well be on the way to mastering political communication. But policy will never be the focus of John Ternus. He is, and probably always will be, the product-guy CEO. Before we ended our conversation, Ternus had one question for me: “What did you think of the logo?”

This is an edition of Steven Levy’s and Lauren Goode's Backchannel newsletter . Read previous newsletters here.

Critical Xen Orchestra auth bypass flaw exploited to hijack VM servers

Bleeping Computer
www.bleepingcomputer.com
2026-11-10 11:17:16
A critical authentication bypass vulnerability in Xen Orchestra is being actively exploited in attacks that could grant administrator privileges and allow takeover of XCP-ng virtualization hosts. [...]...
Original Article

Xen Orchestrator

A critical authentication bypass vulnerability in Xen Orchestra is being actively exploited in attacks that could grant administrator privileges and allow takeover of XCP-ng virtualization hosts.

Xen Orchestra is a web-based management platform developed by French software company Vates, used to manage XCP-ng virtualization environments, including virtual machines, hosts, and pools.

The vulnerability, tracked as VSA-2026-062, affects Xen Orchestra and the Xen Orchestra Appliance (XOA) and allows remote attackers with network access to the management interface to bypass authentication using a specially crafted cookie. A CVE identifier and CVSS score have not been assigned yet.

image

According to a Vates security advisory , the flaw stems from how Xen Orchestra processes authentication tokens sent through REST API requests.

The flaw stems from how Xen Orchestra processes authentication cookies.

By sending a specially crafted cookie ( authenticationToken=j:%7B%7D ) containing an empty JSON object ( {} ), attackers can trick the platform into retrieving an existing authentication token and logging them in as its owner, without requiring actual credentials.

Once authenticated, attackers can retrieve "reusable login token IDs" through the /rest/v0/users/me/authentication_tokens REST API endpoint, which can be used for further access.

"An adversary can bypass authentication and perform actions with 'Admin' privilege. Xen Orchestra compromise can lead to arbitrary code execution on managed pools and a full XCP-ng node takeover as root ," warns Vates .

The company has released Xen Orchestra 6.9.1 (stable) and 6.10.0 (latest), including patched xo-server packages 5.211.2 and 5.213.1 to fix these security vulnerabilities.

Administrators should install the update immediately, and if not possible, restrict Xen Orchestra access to dedicated management networks and block known malicious IP addresses.

Security researchers Filip Magic and Christoffer Olsen of TDC NET Security discovered the vulnerability.

Exploited in attacks

Vates confirmed that the vulnerability is being actively exploited and shared the following indicators of compromise (IOCs) to help administrators identify attacks:

  • Attacker's infrastructure: Connections to 91.211.251.112:8001 or ustar3rqxgnskzgnwkgpofgtvxevm6cx3lxdbwt4mndtveqyaohid.onion:3333 .

  • Suspicious authentication cookies: HTTP requests containing authenticationToken=j:%7B%7D or authenticationToken=j:{} .

  • Virtual machines: A VM named pivot2 .

  • Modified VM configurations: Virtual machines configured with the hvm_serial: file parameter.

  • Unusual files: /etc/cron.d/zz-ustar , /etc/cron.d/zz-ustar2 , /.ustar5 , and /.ustar6 .

Administrators can also run the following commands on XCP-ng hosts to check for unusual VM configurations, virtual machines configured to use a file for its serial port, and malicious files: 

xe vm-list params=name-label,platform | grep -B1 'hvm_serial: file'

zgrep -- '-serial file:' /var/log/xensource.log*

ls -la /etc/ld.so.preload /.ustar* /etc/cron.d/zz-ustar*

However, Vates warns that exploitation will not generate any identifiers in logs, such as the use of specially crafted cookies, and instead must be detected through HTTP monitoring.

The company also says these IOCs are only associated with this known attack campaign and may differ for other threat actors.

Companies that believe they are compromised should rotate passwords and secrets used by their virtualization environments.

article image

Uncover email threats your existing defenses may miss.

Adaptive Security's AI agents analyze email intent, context, and behavior to uncover phishing, business email compromise, and invoice fraud.

See what's getting through with a 14-day read-only scan of Microsoft 365 or Google Workspace, with no MX changes.

Start your free email security scan.

Blender 5.3 released with Gaussian Splat support

Hacker News
www.blender.org
2026-11-10 11:15:43
Comments...
Original Article

Watch the Recap Video

New features overview by Jonathan Lampel and Wayne Dixon from CGCookie .
4D Gaussian Splatting - Nunchuck

Make a Splat

Welcome native 3D Gaussian Splats support to Blender 5.3!

Import them as point clouds, experiment with Geometry Nodes, preview them in Workbench, and render them natively with EEVEE or Cycles.

Gaussian Magic

3D Gaussian Splats are commonly used to reconstruct 3D scenes from photos or videos. They consist of many small, soft, transparent blobs that combine to represent complex geometry and shading.

Blender can now import Gaussian Splats from PLY , SPZ , and glTF files, store them as point clouds, process them with Geometry Nodes, and render them in EEVEE, Cycles, and Workbench (solid mode).

PLY file imported as gaussian splats, featuring DOGWALK by Blender Studio.

Point Cloud Gaussian Splat settings

Point of View

Gaussian splats are represented as point clouds, using a new type to tell them apart and with special attributes:

  • scale : A vector represneting the size of the splat.
  • rotation : A quaternion to control the rotation of the splat.
  • radiance:base : 4D Vector as base (DC) radiance of the splats, followed by opacity.
  • radiance:sh_{index} : Coefficients of the spherical harmonics bands >= 1. The order is <L=1 M=-1> , <L=1 M=0> , <L=1 M=1> , <L=2 M=-2> … where L is the band index and M is the basis function.

Radiant Future

By default, a 3D Gaussian Splat is rendered using an emissive shader. The radiance attribute provides access to the resolved radiance of the splat at the current shading point.

There is rudimentary support for making the splat relightable by replacing the Emission node with a hard surface BSDF such as Diffuse BSDF.

Performance is still being optimized. Rendering may produce inaccuracies due to differences between the sRGB space used by most Gaussian Splat authoring tools and Blender’s linear color space, particularly in areas with low opacity and high radiance.

Example of relit Gaussian Splat
Simple example of relit Gaussian Splat.

More About Shading

CYCLES

Divide and Shine

The Principled BSDF now supports Dispersion !

Turn ordinary glass and diamonds into beautiful little rainbows by splitting white light into its colorful components.

Cycles Dispersion overview on YouTube by Chris Tyler

Butterflies specter shader by Cartesian Caramel

CYCLES

A diamond
in the Rough

With Dispersion in the Transmission panel, the Principled BSDF can now reproduce the characteristic rainbow effect seen in glass and gemstones. This corresponds to OpenPBR v1.1.1.

Roughness anisotropy is also now supported by the Glass BSDF and the transmission component of the Principled BSDF. It behaves just like anisotropy for specular reflections.

CYCLES

Gone with Denoise

Blender 5.3 integrates DLSS 4.5 Ray Reconstruction as a new denoiser, delivering cleaner images faster by upscaling and reusing samples from previous frames.

Think Cycles looks with EEVEE responsiveness.

Find DLSS denoising in the Denoise panel under Sampling.

NVIDIA DLSS brings near-final render quality to the viewport, making lighting and look development faster and more responsive while virtually eliminating flickering between frames during animation playback.

Find it in the Denoise panel under Render properties, Sampling.

DLSS denoising requires NVIDIA driver version 620 or newer.

NVIDIA RTX Spark

Ready to Spark

Blender 5.3 brings native support for NVIDIA RTX Spark devices running Windows 11, including memory optimizations.

EEVEE

Lights Meet Material Nodes

Material Lighting nodes allow authoring how the Material reacts to Lights.

This can, for example, be used for toon and stylized shading, but also for complex physical effects like iridescence.

All the nodes you need to adjust lighting to your liking.

Lighting to Your Liking

Per-light data, evaluation, and shadow information are now available in the Shader Editor, giving you more control over how materials respond to individual scene lights.

Four new nodes and two that received a “Light” mode/space:

A Wider Perspective

EEVEE can now render panoramic cameras, supporting all types of projections, from equirectangular and cubemap formats to various fisheye models and mirror ball.

EEVEE fisheye matching Cycles 1:1

The current implementation has a few limitations: depth of field, raytracing, and volumetric temporal reprojection in the viewport are not yet supported.

More in EEVEE & Viewport

COMPOSITOR

Side Effects

You can now stack Effects on your scene just like you would modifiers or constraints.

Applying compositing effects has never been easier.

Scene Effects stack featuring Storm by Blender Studio
New Compositor & Effects tab in the Properties editor.

One-click, Bloom !

Choose from built-in effects such as Bloom , Chromatic Aberration , Film Grain , and Vignette , as well as effects from online asset libraries or your own custom compositor node groups.

Internally, each effect is its own node group, with its output passed on to the next effect.

You can further customize effects at any time in the Compositor editor.

COMPOSITOR

Bundle Up

17 Geometry Nodes are now supported in the Compositor, bringing a range of new capabilities across bundles , math and logic, and utility operations.

This includes bundle support with Get Bundle Item , Store Bundle Item , Combine Bundle , Typed Bundle , and Separate Bundle .

Math and logic nodes such as Boolean Math , Compare , Float to Integer , Integer Math , Matrix SVD , Combine Transform , and Separate Transform . Plus utility nodes including Hash Value , Random Value , Is Viewport , Import Text , and Bone Info .

  • Blender 5.2
  • Blender 5.3

  • CPU

  • NVIDIA GPU

  • Apple GPU

  • Relative time to process Anisotropic Kuwahara filter. Lower is better.

More in Compositor

Blender 5.3 Splash by Blender Studio

Study the artwork

Blender splash artwork source files are available for you to play with!

Blender 5.3 Splash by Blender Studio
OVERGROWN, by Blender Studio
File Project menu
The new File → Project menu, to create, open and access projects.
CORE

Blender, meet projects .

Until now, Blender’s preferences (such as asset libraries) were shared across all projects, and it was up to users to keep related files and resources organized.

Blender now supports projects, giving you a way to group related files, share resources, and manage settings across an entire project, whether you’re working alone or as part of a team.

Everything
Everywhere
All In a Project

Projects support custom variables that can be used throughout a project, such as a character’s name or a frequently used file path.

Per-project asset libraries and color management configurations are also supported. You can even set up a custom splash screen for your project, providing quick access to its files and other recent projects.

Add-ons and other extensions per-project will follow in future Blender versions.

Projects are entirely optional, most of the time you’ll probably work without one.

Project Splash
Project-specific splash and color management configuration.

Charge Open Movie

ASSETS

Asset Libraries ♥ Extensions

Asset libraries can now be shared as extensions! Just like add-ons or themes.

Browse hundreds of public domain assets available on the Extensions platform via the Get Extensions tab and install them directly from within Blender.

Create and share your own asset library extension. Optionally, access can be controlled via authentication tokens .

Extension Asset Libraries
A selection of public domain assets by the popular library Poly Haven is now available from within Blender. No add-ons required.
GREASE PENCIL

Drawn to Select

Draw Mode now has its own selection tools: Tweak , Lasso , Box , and Circle . Select strokes and adjust them right where you draw.

Move, rotate, scale, duplicate, copy, paste, and delete strokes using the usual shortcuts, or access all these actions from the new Stroke menu.

Carve Diem

Meet the new Carver tool in Draw Mode.

It cuts shapes using proper Boolean subtraction, creating clean cuts in strokes and fills based on a lasso selection. Holes are created automatically when needed.

When a shape has both a stroke and a fill, carving a hole into it also creates a stroke around the hole. Fills that are split apart become separate shapes, making them easy to sculpt further.

The new Carver tool uses booleans to cut through strokes and fills.

Fill with color multiple regions at once using the new Fill tool in Blender 5.3.

One Tool to Fill Them All

The Fill tool can now fill multiple regions at once.

Simply draw a path across multiple regions to fill them all as a single shape, with no gaps or borders in between.

Ramp It Up

Gradient fills now use a ColorRamp input instead of being limited to just two colors.

Assign Flip View a shortcut or add it to Quick Favorites for easy access.

Flip Out

Mirror the camera view horizontally with the new Flip View operator to evaluate the composition from a different perspective and spot asymmetry or visual imbalances.

This only affects the viewport display. It does not change the camera object’s transform or the final render, which remains unchanged. Use the operator again to restore the original orientation.

Flip View has no shortcut assigned by default, but you can assign your own through the right-click menu or add it to Quick Favorites (Q) for easy access.

I/O

USD Collection Importer

Collections can now be associated to importers .

Similar to the Collection Exporters introduced in Blender 4.2 LTS, Collection Importers make it easy to re-import data with a single click, without having to navigate menus or adjust settings repeatedly.

Configure them through the Importers panel under Collection Properties. Settings are stored in .blend files, making them easy to share and preserving them across Blender sessions.

Only the USD importer is supported in Blender 5.3.

See all USD , Alembic , glTF , OpenEXR , and other I/O changes.

VIDEO SEQUENCER

Cut to the chase

The Video Sequencer gets a full ripple editing framework, a rewritten blade tool, and a long list of editing, interface, and performance improvements, including initial OpenTimelineIO support.

Ripple,
Shuffle,
Overwrite

Welcome Ripple editing to Blender 5.3!

This new overlap mode automatically moves strips forward or backward as edits are made, maintaining timeline continuity without the need to manually close gaps.

Ripple , Shuffle , and Overwrite modes are now consistently used across editing operations. Switch between them while moving strips using R , S , and V .

Making Waves

Complete the ripple workflow with these handy operators:

Ripple Add : Hold Shift while dragging and dropping strips to insert them using ripple behavior, automatically making room in the timeline.

Ripple Trim : Trim selected strips at the playhead and automatically close the resulting gaps. Use Shift+Q or Shift+W to trim from either side.

Ripple Delete : Delete selected strips and move subsequent content back to close the gaps. Use Shift+X .

Cutting Edge: Blade 2.0

Splits are now visualized as a line when using Blade and as a region when using Box Blade . Tooltips display frame values at the split location, while a real-time preview shows the frame beneath the cursor.

Press and hold C in the timeline to temporarily activate the Blade tool.
Release it to switch back to the previously active tool.

But wait, there’s more: Hardware decoding , thumbnail support for Scene and other strips, OpenTimelineIO import and export, and much more.

USER INTERFACE

Search. Sort. Scribble.

Blender 5.3 gets more than a layer of polish. Long-awaited quality of life features and improvements that make this release take a leap in usability.

Sorted Out

Arrange your objects freely with custom sorting in the Outliner. Finally.

Switch back to alphabetical order from the header popover.

Plus improvements to filtering, drag-and-drop behavior, and hierarchy management.

Place objects anywhere you want in the Outliner.

Press Ctrl/Cmd + F to find anything in the sidebar.

Side Quest

Sidebars in all editors now support search , making it possible to find any property or operator, even inside tabs created by add-ons.

Press Ctrl/Cmd + F while hovering the sidebar and start typing right away, or through the context menu of the tabs and panels.

To clear the search, press Alt/Option + F .

Mark it Down

The Blender UI now supports rendering basic Markdown formatting.

In node editors, write markdown directly in the new Comment node, or in regular layouts for scripts/add-ons through the label_markdown widget. Another handy widget for long strings is label_multiline , it behaves just like labels but allows text to wrap.

Markdown comment node
New Comment node to annotate node trees, with Markdown support. Rendered node on the left, Edit mode on the right.

But wait: IME support , improved tooltips , box-select gesture, browsable node editor context paths , better Attribute Viewer overlay, Curve widget selection, and more!

What’s Next ?

Blender on tablets, texture layers, animation layers? Show your support for upcoming development projects and help shape the future of Blender.

BUT WAIT, THERE’S MORE

Plus hundreds of bug fixes, code cleanups and refactors.
See the full list of changes .

CREDITS

Flying cars could launch in China next summer, maker of two-seat model says

Guardian
www.theguardian.com
2026-11-10 11:14:50
XPeng says its $300k low-altitude device will soon be ready for emergency services and recreational use in rural areas People could start taking trips in flying cars in China as soon as next summer, the manufacturer of a two-seater vehicle with autopilot model has said. Deli Zhao, the chief executiv...
Original Article

People could start taking trips in flying cars in China as soon as next summer, the manufacturer of a two-seater vehicle with autopilot model has said.

Deli Zhao, the chief executive of the Chinese flying car company XPeng, said the $300,000 (£225,000) low-altitude device would be ready for use by recreational users in rural locations and by emergency services in the second half of 2027. After 10 years of development including trials of flying motorbikes at the company’s Guangzhou base, it has been approved by China’s civil aviation authorities for limited use.

The small cockpit is about the size of a Fiat 500 car and the vehicle is lifted into the air by six drone-like battery-powered propellers and steered by a simple joystick. It can also fly autonomously to a programmed destination, but Xhao, a trained pilot, claimed he could teach anyone to fly it in five minutes.

The price tag for the contraption includes a six-wheel van about the size of a Ford Transit, out of the back of which the flying vehicle unfolds “just like the Transformers”, said Zhao. He has been developing flying cars for almost a decade and said he was part-inspired by the flying creatures ridden by humans in the Harry Potter stories and the Green Goblin’s flying skateboard from the Spider-Man comics.

The flying car hovers above water with Dubai city skyline behind
The flying car during a demonstration in Dubai last month. Photograph: Giuseppe Cacace/AFP/Getty Images

“The world where everyone can be a captain is about to arrive,” he said at the Web Summit in Lisbon on Tuesday, where a prototype of the vehicle drew large crowds. Zhao said no one had yet been injured or hurt using the vehicle which, although described as a car, lacks wheels and is better described as a helicopter-style drone. He said the initial target market was people who were into “diving, surfing, off-roading and flying”.

Elon Musk last month showed off his version of a flying Tesla which uses high-powered blasts of gas to twist and flip in the air. Amid intense competition between the US and China over the development of electric vehicles and drone technology, Zhao said Musk’s prototype was “really hopping or jumping and not really flying”. The XPeng vehicle can cruise as high as 1km above the ground – well below an unpressurised light aircraft such as a Cessna.

“I’m looking forward to seeing a potential future generation that can actually fly,” he said, and agreed when asked if Musk’s showcase had the characteristics of a circus act.

Tesla’s redesigned ‘flying car’ Roadster performs a ramp-assisted mid-air flip

However, the XPeng “flying car” also has limited scope. It will only be usable in approved park areas in China and by emergency services needing to reach inaccessible areas. It has a flight range of 30km (18.6 miles), although this will soon be doubled by increasing the battery’s energy density to 400 kilowatts per kilogram.

skip past newsletter promotion

Its emergence is part of a wider push by Beijing to develop what it calls the “low-altitude economy” – including drones and flying cars, starting with flying cargo, then people, and moving from rural areas to the cities. Zhao said his firm was one of about 20 in China working on flying vehicles.

“All cars in the future will grow wings and all transportation will move from two dimensions to three dimensions,” said Zhao, who claimed he had signed agreements with the United Arab Emirates and countries in south-east Asia to develop the flying car’s use, adding: “We aim to enter the European market as soon as possible.”

Anthropic targets valuation of up to $1.4tn in stock market flotation

Guardian
www.theguardian.com
2026-11-10 11:13:13
Claude chatbot developer had been reported to be aiming for $2tn IPO on Wall Street before investors cooled on AI Anthropic is seeking a valuation of up to $1.4tn (£1.05tn) in its imminent stock market flotation, short of the $2tn that had been expected before investors started to question the durab...
Original Article

Anthropic is seeking a valuation of up to $1.4tn (£1.05tn) in its imminent stock market flotation , short of the $2tn that had been expected before investors started to question the durability of the AI boom.

The developer of the Claude chatbot was widely reported to be targeting a $2tn initial public offering on Wall Street but its sights have been set lower, according to a US regulatory filing on Tuesday.

Anthropic is aiming to raise up to $64.4bn by selling 825m shares in the IPO priced up to $78 a share, giving the company a valuation of up to $1.4tn. The California-based company will also raise a further $26bn via a separate private placement deal ⁠with cornerstone investors including the Google parent, Alphabet, and the chipmaker Nvidia. Trading in Anthropic shares could start as soon as next week.

Investor jitters over the AI boom were crystallised last week when the US midterm elections produced victories for datacentre opponents. This has added to already existing concerns, such as how quickly – or if at all – companies can generate a return on their spending on AI infrastructure.

Brian Hopkins, a principal analyst at Forrester Research, said the midterm elections gave investors the chance to correct valuations that they were beginning to have concerns about, because of worries about the financial sustainability of the AI build-out. The election results brought those concerns to a head, Hopkins said.

“The market needed an excuse to correct itself a little bit in terms of valuations,” he said. “The US election spook is what has caused it.”

As a consequence, Anthropic’s valuation has also been lowered from an anticipated $2tn, he added. The largest ever stock market listing is Elon Musk’s SpaceX, which joined the US stock market with a valuation of $1.78tn. The company, whose assets include Musk’s rocket launch business and the X social media platform, is now worth just under $2tn.

A Chinese spying scandal enveloping Nvidia , a cornerstone company for AI investors, also threatens to overshadow the industry but has not affected share prices so far – other than Nvidia’s.

The updated Anthropic filing stated that the company’s annual revenue is now running at $81bn as of 31 October, up $10bn from the previous month.

Gemini 4 Carbon is now available

Hacker News
blog.google
2026-11-10 11:07:15
Comments...
Original Article

Developers, enterprises, scientists, and consumers can now try our latest frontier model.

Today, we’re making Gemini 4 Carbon available to developers, enterprises, scientists, and consumers. Carbon is our strongest model with frontier performance in cybersecurity capabilities and long-horizon agentic workflows across complex knowledge work, software engineering, and scientific reasoning.

Two weeks ago , we released Carbon to a set of cybersecurity defenders via our Fairwind Program . Following our recent launch of Gemini 4 Argon , Carbon pushes the frontier even further. Argon remains the ideal choice for the majority of software engineering and knowledge work, while Carbon is built for tasks that test the limits of a model’s intelligence like complex, multi-step coding and debugging and open-ended scientific research and discovery — using more tokens than Argon to explore thoroughly, reason deeply, and run extended verification loops.

Across independent benchmarks designed to test model performance in real workflows, Carbon pairs frontier accuracy with practical production economics. It ranks #1 on CursorBench 4.0 , Perplexity’s WANDR , and Zapier’s AutomationBench at more than 2X lower cost per task compared to the next best external model.

To put Carbon’s capabilities to work on larger and complex projects, we’re previewing /swarm in Google Antigravity, turning a single prompt into a coordinated team of agents you can track in real time. Developers can assign Carbon to roles that demand the deepest reasoning, like architectural design, coordination, and auditing, while pairing it with faster, lighter models across parallel isolated workspaces and adversarial verifiers that test every change.

Gemini 4 Carbon is available via the API in Google AI Studio and Gemini for business for all paying developers and enterprises, at the same introductory price 1 as Gemini 4 Argon ($2 per million input tokens and $10 per million output tokens). It is also rolling out to all Google AI Ultra subscribers in Google Antigravity , the Gemini app , and AI Mode in Search .

Higher-precision knowledge work, artifact generation, and data analysis

Across legal, finance, and enterprise operations, Gemini 4 Carbon combines frontier visual understanding, reasoning, and exhaustive retrieval to synthesize grounded insights across large sets of dense documents and data. It follows strict schemas and formatting to generate polished and precise spreadsheets, presentations, and reports.

Existing benchmarks don’t adequately capture how agents reason natively over dense files with charts, images, blueprints, schematics, and tables, so we partnered with Artificial Analysis to launch the new Multimodal Knowledge Agent (MKA) benchmark that tests a model’s multimodal performance in agentic workflows. Carbon ranks #2 while being more than 6X lower in average cost per task compared to the top performing model.

In pre-release evaluations, Carbon matched the performance of the best model tested on deep financial research on Hebbia’s E2E Financial Agentic evaluation, and ranked at the top out of 23 frontier model configurations on Balyasny Asset Management’s General Financial Intelligence benchmark, spanning legal expertise, agentic tool use and execution, coding and data engineering, and perception and context understanding.

Improved agentic coding, full stack development, and 3D and UI design

Carbon performs exceptionally well on engineering tasks that require multi-agent collaboration like multi-package migrations, cross-subsystem root-cause investigations, and complex architectural redesigns. For web app development, it runs build-and-verify loops, recovers from errors, and checks both its code and the rendered UI to produce complete, working applications. Stronger visual design, spatial reasoning, and attention to environmental detail also carry over to 3D game development and creative coding.

Frontier cybersecurity capabilities

Gemini 4 Carbon for cyber delivers our strongest cybersecurity capabilities to date, giving security teams the end-to-end intelligence they need in protecting critical software. When accessed through the Fairwind Program, Carbon leads on key benchmarks across finding (SEC-bench Pro), exploiting (ExploitGym), and patching (CWE-bench v1) vulnerabilities: inspecting software, tracing how flaws can be chained together across systems, and generating verified root-cause patches.

Early testers inside and outside of Google are already seeing strong results with Carbon for cyber in practice.

  • In Project Fortify , Google’s autonomous system spanning scanning, triage, and remediation, Carbon hit 100% recall on scanning and 95% precision on triage, on our internal benchmark. On Open Source code repository testing we see an over 25% relative improvement on Argon's already strong recall rate, surfacing previously undetected, real-world logic flaws. Bringing these gains across Google, one of the world’s largest users of open-source software, helps secure both our own systems and the broader ecosystem.
  • Google’s Cloud Vulnerability Research (CVR) team recently used Carbon to prove that two bugs in a popular open-source software were in fact exploitable vulnerabilities, comparable in severity to the recent PHP2Shell exploit . By using Carbon to build a proof of concept, CVR helped maintainers re-classify the bug as critical and swiftly issue a patch. Details will be shared after the responsible disclosure process completes.
  • As part of Wiz’s Scan for Good program, the team used Carbon to assess vulnerabilities in public digital infrastructure. For example, when scanning two major SaaS providers, the model uncovered 0-day vulnerabilities in under two hours compressing weeks of vulnerability research to a single afternoon. The team partnered with the impacted organizations to remediate in record time, helping to mitigate potential impact on tens of thousands of companies.

Stronger scientific and mathematical reasoning

Gemini 4 Carbon shows strongly improved performance in reasoning across physics, math, and life sciences, synthesizing experimental data, testing hypotheses, and reasoning through multi-step domain problems. For drug toxicity research company Axiom Bio, Carbon is now the leading model in performance for translational science, finding novel mechanisms of toxicity they hadn’t found previously. Axiom is now moving their production scientific analyses and agents to both Carbon and Argon to unlock the creation of safer drugs.

Researchers across Google have been using Carbon in Google Antigravity to accelerate their work:

  • Code verification: Researchers built a new agentic framework for formal verification called AlphaProof Code and put it to work on a major security challenge: mathematically proving the actual code underlying the cryptographic protocol of Signal . Using Carbon alongside other models, our researchers translated security goals to mathematical theorems. AlphaProof Code agents then used Carbon to generate millions of lines of code in Lean, a computer language for writing mathematical proofs, helping them prove key security properties in weeks — a task that historically takes expert teams years. The result indicates Carbon’s potential to unlock scalable formal verification, long considered a gold-standard approach to building secure software.
  • Enzyme assay development : Provided with only lab notebooks and raw data, Carbon went beyond standard analysis to surface hard-to-interpret data anomalies, which it used to diagnose subtle wet lab experimental artifacts such as incomplete automated mixing in deep wells, leading to substantially improved reproducibility. Moreover Carbon improved methods to deconvolute chromatography peaks and caught trace sample carryover in research instruments, significantly accelerating the development of new assays and tightening the feedback loop between computation and the bench.
  • Protein structure prediction: Structure prediction models like AlphaFold 3 use Multiple Sequence Alignments (MSAs) of evolutionary relatives to help infer how amino acid chains fold. As a result they often struggle on understudied, viral, microbial, and eukaryotic proteins that have very few matches in standard databases. Working in a multi-agent setup, our researchers used Gemini 4 Carbon to autonomously discover remote homologs across petabase-scale unannotated sequence archives, environmental and viral sequence catalogs, and 3D structure databases. For example, across 7 low-homolog protein families from the CASP17 blind test set, Carbon increased the number of homologs retrieved by 40-fold on average, greatly increasing the information available to structure prediction models without need for retraining. While broader benchmarking is still underway, addressing this upstream search bottleneck potentially offers a promising path toward modeling hard-to-characterize regions of the proteome.

Four weeks ago, we opened applications to give 10,000 scientists access to Argon in Google Antigravity free of charge for six months to accelerate the pace of their research, and we’ve onboarded thousands of scientists already. Today, we’re expanding access to Carbon for current and future participants, and going forward, the program will continue providing access to our latest frontier models as they become available. Applications remain open and onboarding continues on a weekly rolling basis, subject to eligibility, capacity, and selection.

Progress in model safety and security

With each new model release, we continue to strengthen our safety and security mitigations, agentic misuse prevention, model alignment, and harm reduction proportionately with model capability.

Because Gemini 4 Carbon introduces stronger cyber capabilities we build on Argon’s strong safety and security stack to fortify robustness to misuse and prompt injection.

  • Mitigating frontier safety misuse risks: We’ve strengthened our misuse safeguards to help ensure stronger defensive reasoning does not translate into offensive risk. In simulated cyberattack testing environments seeded with ExploitBench and CyScenarioBench, Carbon blocked 99% of attack trajectories from our adaptive red-teaming agent that can iteratively revisit its attack plans after each block. The Carbon safeguards lowered the per-attempt breach rate to just 0.8% (down from 3.1% on Argon). Our safeguards also lowered the automated cyberattack query success rate to 2.17% in Gray Swan’s testing, compared to 9.86% on Argon. And external testing by Trajectory Labs found zero new universal jailbreaks across 132 hours and over 13,000 requests.
  • Promoting safe and aligned model interactions: When we announced Carbon, we showed significant improvements in alignment as measured by our monitor flag rates across the model’s lifecycle, as well as reductions in data fabrication. New results show that on our 375-task agentic honesty benchmark, it passed 92% of tasks (compared to 70% for Argon) — declining to fill in missing experimental data 98% of the time and flagging methodological flaws 68% of the time.

a chart showing measures of misalignment across a model's lifecycle

  • Protecting users from indirect prompt injection attacks: Two weeks ago, we shared that Carbon achieved a 0% prompt injection attack success rate on the Gray Swan IPI benchmark — marking the first time that milestone has been reached. At the same time, we know that prompt injection robustness remains an area for continued improvement. Our advanced automated red teaming continues to push the limits here and has shown that models could be further improved against sophisticated attacks in some distributions. It provides the data for us to continuously advance our models’ security to the next frontier.

For more details, read the full Gemini 4 Carbon Safety and Security report .

Getting started with Gemini 4 Carbon

Starting today, Carbon joins Argon in our family of frontier models across our products:

  • For developers: Build with the Gemini API paid tier in AI Studio and Android Studio , and if you’re a Google AI Ultra subscriber, you can try it in Google Antigravity and AI Studio.
  • For enterprises: Try it in Gemini for business via the API or model drop down, Google Antigravity, or CodeMender.
  • For everyday users: Try Carbon starting today in the Gemini app and AI Mode in Search if you’re a Google AI Ultra subscriber.
  • For scientists & researchers: Apply for a chance to get access to both Argon and Carbon via Google Antigravity’s highest usage tier free of charge for 6 months (onboarded on a rolling basis), subject to eligibility, capacity, and selection.
  • For cybersecurity defenders: Apply to join the Fairwind Program to get access to Carbon for cyber on a rolling basis.

See the model card to learn more about Gemini 4 Carbon and to start building with it, explore our updated Gemini 4 developer guide and documentation for best practices on migrating workflows to the model.

Get the latest news from Google in your inbox

Sign up for our newsletters with product updates, event information, special offers, and more.

Your information will be used in accordance with Google's privacy policy. You may opt out at any time.

.NET 11

Hacker News
devblogs.microsoft.com
2026-11-10 11:01:27
Comments...
Original Article

Today, we’re excited to announce the release of .NET 11! This year’s release makes building modern applications faster, more productive, and has improvements across C# 15, ASP.NET Core, .NET MAUI, and Windows development. With hundreds of runtime optimizations, more responsive SDK tooling, and less overhead in everyday commands, you can spend less time waiting and more time creating. Build richer web and cross-platform applications, take advantage of new C# language features, and explore AI-powered development with improved tools and agentic capabilities.

.NET 11 support

.NET 11 is a Standard Term Support (STS) release with two years of support under the .NET support policy . STS and Long Term Support (LTS) releases have the same quality and servicing policies; the difference is the length of support. .NET 10 remains a supported LTS option. Stay current with servicing updates whichever release you choose.

Join us at .NET Conf, November 10-13

Explore .NET 11 with the product teams and community at .NET Conf 2026 . The conference includes product team sessions on November 10 and 11, followed by two days of community sessions.

Watch the Day 1 livestream, including the keynote , or browse the conference session playlist .

Announcing .NET 11

What’s new in .NET 11

Some of the changes we’re most excited for you to try:

  • C# 15 union types and closed hierarchies help you express the possible states of your application and handle them with compiler-checked patterns.
  • A Native AOT CLI host and a warm MSBuild server reduce overhead in everyday developer workflows.
  • ASP.NET Core brings asynchronous validation, OpenAPI 3.2, and new capabilities for Blazor and SignalR applications. Experimental Blazor AI components integrate with the Agent User Interaction Protocol (AG-UI) for advanced agentic web experiences.
  • Build AI-powered, agentic applications with Microsoft.Extensions.AI (MEAI) for model access, MCP for tool integration, and Microsoft Agent Framework (MAF) for agents and workflows.
  • Put agentic development tools to work with .NET Skills for .NET-specific guidance, .NET MAUI DevFlow for inspecting and testing running apps, and the .NET Upgrade canvas for reviewing modernization progress.
  • .NET MAUI adopts CoreCLR as its default runtime and improves XAML iteration and native controls.
  • The libraries add built-in Zstandard compression, simpler process execution, richer JSON support, and new ways to work with in-memory data without copying it first.

The what’s new in .NET 11 overview links to the full details. Here are the changes behind those headlines and how to start using them.

Languages

C# 15

C# 15 is the default language version for projects targeting .NET 11. Union types are one of its biggest additions: a value can be one of a declared set of case types, with conversions from those types and exhaustiveness checking in switch expressions.

Consider a product lookup that either finds a product or reports that it wasn’t found: 

ProductLookup result = new Product(42, "Mechanical keyboard");

string message = result switch
{
    Product product => $"Found {product.Name}",
    ProductNotFound missing => $"No product with ID {missing.Id}",
};

Console.WriteLine(message);

public sealed record Product(int Id, string Name);
public sealed record ProductNotFound(int Id);
public union ProductLookup(Product, ProductNotFound);

The result type tells a caller which outcomes it needs to handle. There’s no need to use object or an unrelated base class just to put those outcomes behind one return type.

C# 15 also adds closed hierarchies . A closed class limits direct derivation to its declaring assembly, giving the compiler the information it needs to check patterns over the hierarchy. Unions are useful when you want to combine existing types; closed hierarchies fit models where you own the inheritance relationship.

Smaller language features help with everyday code, too. Collection expression arguments let you pass constructor or factory arguments without giving up collection expression syntax: 

HashSet<string> names =
    [with(StringComparer.OrdinalIgnoreCase), "Alice", "ALICE", "Bob"];

Console.WriteLine(names.Count);

This prints 2 : the comparer controls equality, so "Alice" and "ALICE" are one entry.

Other additions include extension indexers and labeled break and continue . These features don’t require the preview language version. The separate memory safety work remains in preview ; see the C# 15 feature documentation for its opt-in requirements.

F# 11

F# 11 improves compiler memory use and reduces allocations in FSharp.Core collection operations. It also adds ways to bound concurrent asynchronous work, useful when a collection operation would otherwise start more work than a service or machine can handle comfortably.

The F# release notes distinguish the default-language updates from preview capabilities, including Runtime Async support for custom computation-expression builders.

Platform

SDK

The SDK now enables a Native AOT CLI host by default. Commands such as help and version queries can run without starting the managed CLI, and tool launches can avoid that startup path too. Commands that need managed execution still use it.

The MSBuild server also stays warm between CLI invocations by default, reducing repeated startup work. SDK installers on Linux and macOS are smaller through assembly deduplication.

File-based apps can grow across source files with #:include , and solution filters can be created and edited from the CLI. dotnet watch adds Aspire app-host integration, crash recovery, and device selection for mobile projects.

For teams using Microsoft.Testing.Platform, dotnet test gains run-level timeouts, failure limits, clearer progress reporting, and per-module results directories. The test runner matters: these switches aren’t interchangeable with the VSTest command-line options.

Container publishing adds reproducible image digests through SOURCE_DATE_EPOCH and avoids redundant layer uploads when the target manifest already exists. NuGet source configuration gains a minimum package publication age setting, which lets teams wait before newly published package versions become eligible for selection. This is an additional policy control, not a replacement for vulnerability checks or reviewing dependencies.

See what’s new in the SDK and tooling for command examples and configuration.

Runtime and performance

Performance work in .NET 11 reaches both the code you deploy and the tools you use to develop it. Stephen Toub’s Performance Improvements in .NET 11 takes a detailed tour through hundreds of runtime and library optimizations, with benchmarks and code examples.

The just-in-time (JIT) compiler improvements remove more redundant bounds checks and branches, improve devirtualization, and fold more operations into constants. For example, the JIT can optimize additional SequenceEqual calls when it knows the inputs at compile time. These changes improve generated code without requiring you to rewrite the corresponding application logic.

Native AOT interface dispatch uses a shared helper that reduces the code needed at interface call sites and improves throughput for interface-heavy workloads. Hardware support also expands, including FP16 instructions for Half operations on supported x64 and Arm64 hardware and new vector construction and composition APIs.

There’s useful work on diagnostics, too. In-process crash report logging can capture a managed stack trace, module information, and runtime state before a process exits. Previously available on mobile platforms, this reporting path now also supports Linux and macOS.

As always, measure the effect on your own application. Throughput, startup time, memory use, and deployment size depend on the workload and publishing options you choose.

Runtime Async has been a recurring theme throughout the .NET 11 previews. It moves asynchronous suspension and resumption into the runtime instead of relying on compiler-generated state machines.

One especially useful result is a clearer live call stack. Profilers and debuggers can show the asynchronous methods themselves instead of the infrastructure used to execute them. This is a distinction from exception stack traces, which already hide much of that infrastructure.

Runtime Async remains a preview feature. To try it in a project targeting net11.0 , add: 

<PropertyGroup>
  <Features>runtime-async=on</Features>
</PropertyGroup>

You don’t need to enable EnablePreviewFeatures for this scenario. The .NET runtime libraries themselves are built with Runtime Async, but opting your application’s code into the new compilation model is a separate choice. See the Runtime Async documentation for its behavior and current guidance, and test your application’s dependencies and diagnostics before adopting it.

AI libraries and tools

The .NET 11 SDK includes an MCP server template . MCP gives AI applications a common way to discover and call tools and services. The template uses the official MCP C# SDK and includes a working sample tool, so you can start exposing your own functionality without first installing a separate template package: 

dotnet new mcpserver -o MyMcpServer

For applications that consume AI services, Microsoft.Extensions.AI (MEAI) provides abstractions such as IChatClient and IEmbeddingGenerator . These libraries let you compose model access with dependency injection, caching, and OpenTelemetry using familiar .NET patterns. They’re available as NuGet packages, rather than features that require you to move all of your application code to a new framework version.

Microsoft Agent Framework (MAF) builds on these abstractions with agents that call tools and maintain conversation state, plus workflows that coordinate agents and application code. Connect agents to MCP tools to give them access to your application’s capabilities, and expose an agent through an ASP.NET Core AG-UI endpoint to build an interactive Blazor experience. The AG-UI hosting integration is currently prerelease.

For hands-on examples, start with .NET AI Essentials: The Core Building Blocks Explained and continue with our Microsoft Agent Framework walkthrough .

Libraries

The .NET libraries add capabilities that previously required extra setup, intermediate buffers, or custom helpers.

The Process API expansion includes one-shot methods to run a process and capture its output and exit status. More advanced APIs give you control over inherited handles, suspended starts, and process signaling. Build tools and developer utilities can spend less code on process plumbing while still inspecting how a child process finished. See Process API Improvements in .NET 11 for examples.

Zstandard compression joins the existing compression formats in System.IO.Compression . New span-based compression APIs support callers that manage their own buffers, and ZIP improvements include CRC32 validation when reading entries.

Four new in-memory stream adapters bridge existing data to APIs that accept a Stream : ReadOnlyMemoryStream , WritableMemoryStream , ReadOnlySequenceStream , and StringStream . For example, a pipeline’s segmented ReadOnlySequence<byte> can be read as a stream without first flattening it into a new contiguous buffer.

System.Text.Json adds support for C# unions, F# discriminated unions, and JSON Lines output from asynchronous sequences. F# union support uses reflection and doesn’t support source generation, trimming, or Native AOT, so check the documented limits before choosing it for a trimmed application.

LINQ adds FullJoin , which preserves unmatched elements from both inputs. This is useful for reconciliation work, such as comparing two inventories where you need to see missing items on either side.

The libraries also expand numeric types, DNS resolution, cryptography, and tracing configuration. The library overview covers the complete set of changes and marks APIs that remain experimental.

Entity Framework Core 11

Entity Framework Core 11 improves how your model becomes a query and how that query becomes SQL.

EF Core removes unnecessary joins in more reference-navigation and split-query scenarios, improves GroupBy translation, and translates the new LINQ FullJoin operator on relational providers that support it. These changes can simplify generated SQL while letting more queries stay in LINQ.

Complex types and JSON columns can now be used on entities mapped with table-per-type or table-per-concrete-type inheritance. Other improvements include migrations tooling and additional provider-specific JSON capabilities.

For SQL Server applications, EF Core adds support for vector indexes and approximate vector search. The SQL Server features and corresponding EF APIs are experimental. See the vector search documentation and limitations before evaluating them.

EF Core 11 requires .NET 11. When upgrading, check your database provider’s compatibility and the EF Core 11 breaking changes as well as the runtime changes.

Developer tools

The new dotnetup toolchain manager lets you install and update .NET SDKs and runtimes in your user account. It’s currently in public preview and helps you manage side-by-side versions and keep up with servicing updates.

.NET Skills gives coding agents task-specific guidance from the .NET team. Our .NET Skills introduction explains how to add these skills to your coding agent.

The experimental .NET MAUI DevFlow toolkit exposes a running app’s visual tree, screenshots, and interaction tools, so an agent can inspect and test the UI rather than work only from source code.

For modernization, the .NET Upgrade canvas gives you a visual view of a GitHub Copilot upgrade session. Review assessment findings and dependency compatibility, follow implementation tasks, and monitor failures and progress as the upgrade agent works. Our modernization walkthrough in the GitHub Copilot app covers the workflow from assessment through execution.

Workloads

Web: ASP.NET Core and Blazor

Application types are most useful when the rest of the stack understands them. ASP.NET Core supports C# unions wherever it uses System.Text.Json , including JSON request and response bodies in Minimal APIs and MVC. Generated OpenAPI documents describe the union’s alternatives with an anyOf schema.

This support applies to JSON bodies, not to route, query, header, or form binding. When multiple union cases have the same JSON shape, configure a classifier so deserialization can distinguish them. The ASP.NET Core union documentation explains those boundaries.

Validation also becomes more practical for rules that need to do I/O. Asynchronous validation works with the new asynchronous DataAnnotations APIs, so a validator can await a database lookup or a remote call instead of blocking a thread. Minimal APIs and Blazor forms can use this support.

OpenAPI 3.2 is now the default for generated documents. Among other improvements, it lets the document describe the per-event payload of a server-sent event stream. If a client generator or another part of your toolchain doesn’t yet support 3.2, you can explicitly select an earlier document version.

For long-lived connections, SignalR authentication refresh lets a connection refresh authentication without reconnecting. Blazor Interactive Server components can receive the updated identity and react when claims change.

Blazor adds capabilities for both statically rendered pages and interactive applications.

The new CacheView component caches the rendered output of a component subtree during static server-side rendering. On a cache hit, Blazor replays the markup without creating those child components or running their lifecycle methods. That gives you a smaller unit of caching for expensive, mostly static sections of a page.

Interactive Server apps can opt into automatic circuit pause when a browser tab becomes inactive . After a configurable delay, pausing frees the server memory and SignalR connection held by an inactive user. The feature requires an additional package and explicit configuration; upgrading doesn’t silently change your application’s circuit behavior.

Forms gain client-side validation for static server rendering and asynchronous validation support. QuickGrid and Virtualize add ways to move to a particular item, useful when returning a user to their place in a large collection.

Blazor also adds components for agentic user interfaces. The new Microsoft.AspNetCore.Components.AI package includes components for streaming chat, tool rendering, approval flows, and shared UI state. Basic chat works with any IChatClient . For advanced experiences with a remote agent, the AG-UI .NET integration carries streamed responses, tool events, approval requests, and shared-state updates between an ASP.NET Core agent endpoint and the Blazor UI.

The Blazor AI components package is experimental and remains prerelease throughout .NET 11. It’s an opportunity to try the direction and give feedback, not a stable part of the ASP.NET Core shared framework. See the Blazor AI components documentation .

The AG-UI .NET SDK introduction covers the protocol’s client and server APIs. Build Agentic UI with the new Blazor AI components puts them together in a working app.

See what’s new in ASP.NET Core for the Blazor features, configuration examples, and compatibility details.

Client: .NET MAUI

.NET MAUI in .NET 11 makes CoreCLR the default runtime across its platforms. The move to CoreCLR brings mobile and desktop apps onto the same runtime foundation as other .NET workloads. On Apple platforms that don’t allow JIT compilation, the runtime uses precompiled code and the interpreter rather than generating native code at runtime.

Native AOT is an opt-in publishing alternative; its Android support remains experimental. Review the platform-specific runtime guidance and test your app’s libraries when choosing a deployment model.

The UI development loop gets attention, too:

  • XAML Incremental Hot Reload is a preview feature in .NET 11. It updates live instances of pages and controls, including supported structural edits, without requiring you to navigate away and back. It’s enabled by default in Debug builds.
  • Implicit XAML namespace declarations remove the need to repeat the standard namespace declarations at the root of every file.
  • Windows uses the new CollectionView2 handler by default, while Android Shell adopts a handler-based architecture.
  • New mobile test templates and dotnet test device selection bring testing into the CLI workflow.

These are meaningful runtime and handler changes, so exercise navigation, custom handlers, and trimmed publishing as part of your upgrade. The optional Microsoft.Maui.Controls.Compatibility package no longer ships; apps that still reference it need to migrate off it.

.NET MAUI follows its own support policy , separate from the .NET runtime’s STS and LTS lifecycle.

Windows: WinUI, Windows Forms, and WPF

For new Windows desktop apps, WinUI 3 is the recommended native UI framework, pairing C# and XAML with modern controls and the Fluent Design System. It’s delivered through the Windows App SDK , which also makes modern Windows APIs available to existing WPF and Windows Forms apps.

To add UI tests, see UWP and WinUI 3 apps: UI testing with MSTest .

Windows Forms in .NET 11 adds an opt-in modern visual styles mode that you can select at the application or control level. It also adds ways to react to system visual and accessibility settings, defer revealing a form until it’s ready, and suspend painting during bulk updates.

These controls let you introduce refreshed rendering where it makes sense for your application instead of treating a framework upgrade as an automatic visual redesign.

WPF updates focus on reliability, including fixes for Fluent window backdrops, window manager failures, and weak-event cleanup. Self-contained Windows publishing also includes a native dependency needed by apps that load mixed-mode WPF assemblies.

Get started and plan your upgrade

Install the .NET 11 SDK . Use a compatible, up-to-date Visual Studio 2026 installation, or Visual Studio Code with C# Dev Kit .

To create and run a console app: 

dotnet new console -n HelloDotnet11 -f net11.0
dotnet run --project HelloDotnet11

You can replace the generated program with either of the C# examples above to try the new language features.

For an existing application, plan the upgrade across your development and deployment environments:

  1. Update the SDK selection in global.json if your repository pins it, and install the matching SDK on development machines and build agents.
  2. Update target frameworks to .NET 11, preserving platform-specific target framework suffixes where applicable. Update packages and workloads to compatible versions.
  3. Review the .NET 11 breaking changes , including the updated minimum CPU requirements . Installing a new SDK alone doesn’t retarget your app.
  4. Run your tests and measure the application under a representative workload. Validate your actual publishing mode, container base images, native dependencies, and deployment hosts.

Upgrading from .NET 8 or .NET 9

.NET 8 and .NET 9 reach end of support on November 10, 2026. Move to a supported release to continue receiving fixes. Choose .NET 11 for the latest capabilities, or .NET 10 if its LTS lifecycle fits your requirements better. See the .NET support policy for dates and servicing requirements.

If you’re upgrading from a .NET 11 release candidate, update to the final SDK, runtime, and compatible package and workload versions rather than staying on a prerelease build.

Thank you for building .NET with us

.NET 11 is the work of over 7,000 contributors . Thank you to everyone who contributed code, tested previews, reported issues, and helped us make better design decisions throughout the year. Your feedback across the previews and release candidates helped shape what we’re shipping today.

The .NET ecosystem continues to grow, with more than 589,000 unique packages on NuGet and over 1.1 trillion package downloads .

Collage of .NET 11 contributors' avatars

Download .NET 11 , try it with an application you know well, and join us at .NET Conf to learn directly from the people building it. Share your results and questions in the .NET GitHub discussions .

Category

Topics

Author

.NET Team

.NET is the free, open-source, cross-platform framework for building modern apps and powerful cloud services.

Palantir hires a former Democratic senator as it faces scrutiny in new Congress

Hacker News
text.npr.org
2026-11-10 10:59:34
Comments...
Original Article

Tech companies are expecting a wave of scrutiny from Democrats for the industry's ties with the Trump administration when they take over Congress in January. In anticipation, many are hiring former Democratic lawmakers and aides to make their case to the incoming House and Senate majorities.

Related Story: NPR

Among the latest to make that move is Palantir , which has hired former Sen. Jon Tester, a colorful Montana Democrat who's also an organic farmer.

"My agreement with Palantir is advisory in nature, it is not lobbying," Tester, who lost reelection to the Senate in 2024, told NPR in an interview.

The secretive American software and artificial intelligence company has drawn the ire of Democrats in Congress during President Trump's second term. Palantir — named by billionaire founder Peter Theil after the mythical "seeing stone" from J.R.R. Tolkien's The Lord of the Rings — has been accused of abetting mass surveillance on Americans and immigrants.

"Perception is reality in Washington, D.C. and in politics in general," said Tester. "But the fact is, I think Palantir has got a good story to tell, and they need to tell it. And hopefully folks will be receptive to it."

Palantir has long denied claims it aids mass surveillance on the American public — saying it doesn't gather or manipulate data at all, but instead creates tools for government agencies and private companies to organize and optimize their own information. The company has said it is committed to "protecting privacy and upholding liberal democratic values."

Earlier this year, while in the minority, Sen. Ron Wyden, D-Ore., along with 30 other Democratic lawmakers demanded answers about Palantir's contracts with the Department of Homeland Security and whether its tools are part of efforts by the federal government to surveil Americans. Palantir denied the accusation and said it is "neither conducting nor enabling mass surveillance of American citizens," but Wyden wasn't fully satisfied with its response, according to his Senate office.

"Senator Wyden has a number of questions about Palantir's work to facilitate the Trump-Vance abuse of government data that he intends to ask again as chairman of the Finance Committee," Wyden's staff wrote in a statement to NPR. "If Palantir is not responsive next year, compulsory processes will be on the table."

It's not a coincidence that tech companies are turning to Democrats to help burnish their reputation, said Aya Ibrahim, a senior fellow at the AI Now Institute and a former State Department official.

"I think at the end of the day, these companies have an inordinate amount of money and they will try and put it wherever they can in order to stave off any real accountability," Ibrahim said.

Related Story: NPR

During Trump's second term, Palantir's CEO and co-founder Alex Karp — a self-described liberal — has been highly critical of Democrats on issues like immigration and AI.

"I would say to my Democratic friends, also of which I still have, I hope many," Karp said in an interview with Axios in 2025 specifically referencing his support for much more restrictive immigration policies. "You have to grow a spine because a lot of these people actually agree with me in private."

During his 18 years in the Senate, Tester was an outspoken critic of the PATRIOT Act that passed shortly after the 9/11 attacks that expanded the Justice Department's surveillance powers. When asked whether his concerns over government surveillance remain and whether he has the same concerns with his new employer, Tester said Palantir is different and that the company doesn't build "big databases" or trade in private data.

"I wanted to do away with the Patriot Act because it was about privacy," Tester said. "It was about making sure that I am not being watched by anybody, including Big Brother. And by the way, I've talked to many people within Palantir. They believe the same way I do. This is an organization that believes in privacy."

Related Story: NPR

Last year, over a dozen former Palantir employees criticized the company over its $30 million contract with U.S. Immigration and Customs Enforcement to create a tool that provides "near real-time visibility" into the movement of migrants. The former employees argued the company violated its own code of conduct by working with the Trump administration on such products.

Related Story: NPR

Valued at over $350 billion, Palantir currently holds $2 billion worth of federal contracts, according to government records . The lion's share are with the Departments of Defense, Homeland Security and State — but the software firm also works with the Departments of Agriculture, Veterans Affairs and Health and Human Services .

Tester said he'll be focused on the government services side of Palantir's work.

The former Montana senator called the midterm election results a blue "tidal wave" after two years of a Congress that gave him "great disappointment."

"It is going to make a difference as far as the policies that are being advocated for," Tester said of the upcoming Congress. "I don't think you're going to see the kind of aggressive tactics that were taken forth by ICE moving forward."

Transcript

LEILA FADEL, HOST:

The tech industry is bracing for a new Democrat-controlled Congress. A company that is likely to face scrutiny has just hired a prominent Democrat. NPR's Luke Garrett reports.

LUKE GARRETT, BYLINE: Palantir is a secretive software firm with $2 billion worth of contracts across the federal government. The majority are with the departments of Defense and Homeland Security. Last year, former employees told NPR the company's products gave DHS near-real-time visibility into the movements of migrants in the U.S. Now some Democrats have vowed to investigate Palantir's work with the Trump administration and whether it's helping the government conduct mass surveillance. Jon Tester, who was a Democratic senator for 18 years, has been hired to advise the company.

JON TESTER: You know, a perception is reality in Washington, D.C. and in politics in general. But the fact is that I think Palantir's got a good story to tell, and they need to tell it. And hopefully folks will be receptive to it.

GARRETT: The company was founded by billionaire investor Peter Thiel, who named Palantir after the mythical seeing stone from "The Lord Of The Rings." Its CEO, Alex Karp, is a self-described liberal who has worked closely with the Trump administration, and he's been highly critical of Democrats on issues like immigration. Here's Karp on "The Axios Show" last year.

(SOUNDBITE OF TV SHOW, "THE AXIOS SHOW")

ALEX KARP: I would say to my Democratic friends, also of which I still have, I hope, many, there - you have to grow a spine because a lot of these people actually agree with me in private.

GARRETT: Tester tells NPR he'll be focused on Palantir's work streamlining government services for farmers and veterans.

TESTER: And I think that's what it's about. I mean, it's about saving money. It's about making sure government works for people.

GARRETT: As a senator, Tester aggressively opposed the Bush-era PATRIOT Act, which expanded government surveillance. When asked if he had the same surveillance concerns about Palantir, Tester said he didn't.

TESTER: I've talked to many people within Palantir. They believe the same way I do. This is an organization that believes in privacy.

GARRETT: Tester's employment at Palantir comes as other tech companies have also gone on a hiring spree of former Democratic lawmakers and aides in anticipation of changing power in Washington. Senior fellow at the AI Now Institute and former State Department official Aya Ibrahim says that's not a coincidence.

AYA IBRAHIM: I think, at the end of the day, these companies have an inordinate amount of money. And they will try and put it wherever they can in order to stave off any real accountability.

GARRETT: Ibrahim says the midterm results are an opportunity to check the growing power of the tech industry.

Luke Garrett, NPR News, Washington.

Binance warns of iOS flaw that could leak crypto wallet secrets

Bleeping Computer
www.bleepingcomputer.com
2026-11-10 10:59:19
Binance is warning about a vulnerability in Apple's iOS 26.7.1, 27.0.1, and 27.2 that could allow third-party apps to read private files stored by other apps, including cryptocurrency seed phrases, secret keys, and login credentials. [...]...
Original Article

Binance warns of iOS flaw that could leak crypto wallet secrets

Binance is warning about a vulnerability in Apple’s iOS 26.7.1, 27.0.1, and 27.2 that could allow third-party apps to read private files stored by other apps, including cryptocurrency seed phrases, secret keys, and login credentials.

The crypto exchange clarifies that the issue is at the iOS level and does not impact only the Binance app.

“A vulnerability (worse_query) affecting iOS 26.7.1, 27.0.1, and 27.2 allows malicious apps to read local files from other apps, putting seed phrases, private keys, and login credentials at risk across the entire ecosystem,” Binance says .

image

At this time, no cryptocurrency losses have been confirmed, but Binance urges users to install the update immediately as a precaution.

The company recommends that users delete any unnecessary and untrusted apps and apply the latest versions for iOS and other apps.

Where compromise is suspected, Binance advises users to transfer funds to a new wallet created on a clean device and reset all active login sessions.

Public exploit available

“worse_query” is a publicly disclosed iOS sandbox escape technique that allows an application to cross security boundaries and access the storage of other applications.

Yesterday, a proof-of-concept exploit has been published that uses a tool called WQ Files to perform attacks relying on the technique. Specifically, WQ Files uses “worse_query” to browse, export, edit, and delete other apps’ data without requiring a jailbreak.

An attacker could

The tool must be installed on an iPhone for the attack to work, but an attacker could distribute it through untrusted sources as a sideloaded app, bypassing Apple's App Store.

WQ Files has been confirmed to work on iOS 26.7.1, 27.0.1, and 27.2, the same versions that Binance warned about.

Apple on November 9 released iOS security updates (iOS 27.2.1, 26.7.3, and 18.7.12) that address nine flaws. One of the fixed vulnerabilities, tracked as CVE-2026-113963, could allow an app to access sensitive user data.

It is unclear if this is the same security issue Binance is warning of, though.

The CVE-2026-113963 problem was reported by László Várady flaw, who found that the access occurred through App Intents, not App Group containers.

BleepingComputer has contacted Apple for clarifications and a request for comment, and we will add an update once we receive more details.

article image

Uncover email threats your existing defenses may miss.

Adaptive Security's AI agents analyze email intent, context, and behavior to uncover phishing, business email compromise, and invoice fraud.

See what's getting through with a 14-day read-only scan of Microsoft 365 or Google Workspace, with no MX changes.

Start your free email security scan.

Ohme’s new EV charger privacy policy drops its pledge not to sell data

Lobsters
blog.popey.com
2026-11-10 10:51:40
Comments...
Original Article

Ohme emailed me today to say they’ve updated their privacy policy . I’ve never read it. Not the one I implicitly agreed to in 2021, nor the 2024 revision, and I certainly wasn’t planning on reading this one.

Ohme Email Banner

Then I thought about what’s actually on the other end of that policy. It’s a box bolted to the side of my house that I touch most days and think about almost never. So I read the new policy , dug the previous version out of the Internet Archive, and compared the two. Living the dream, me.

The charger

Ohme Home Pro

Image from Ohme Home Pro

I had an Ohme Home Pro fitted on 3rd December 2021, a few days before my first EV, a Mini, turned up. I wrote about that car, and a bit about the charger, in Mini EV: Two Years On . The charger came free as an incentive with the car. I didn’t choose Ohme. Ohme came in the box, more or less. Hold that thought.

The old Mini

In December 2024 I got rid of that Mini and got a new one. It plugs into the same charger.

The new Mini

The charger is hooked up to my Octopus Energy account, so it knows when electricity is cheap and charges the car then. That’s the whole point of it, and it works. I plug the car in most days and walk away. The Ohme app is on my phone, but I barely open it, unless I need to override the charge plan.

I’m on Intelligent Octopus Go, which is 36.39p/kWh during the day and 6.60p/kWh off-peak. The current Mini is a Cooper SE with a 54.2kWh battery, of which about 49kWh is usable . Filling it from empty overnight costs about £3.25. Call it £3.60 once you allow for the bit that gets lost as heat while charging. Do the same at the daytime rate and it’s nearer £18.

So the box earns its keep. Which is exactly why I’ve never bothered to wonder what else it’s up to.

What it knows

Have a think about what a smart charger needs to do its job, and you’ve got a fair idea of what it knows about you. Going by the policy, that includes:

  • When I’m home. The car is either plugged in or it isn’t. Five years of that is a pretty decent record of when I’m in, when I’m away, and how boringly predictable I am about it. They also collect “the location of your Ohme cable when it is plugged in”. It’s bolted to my house. I can save them the trouble.
  • What I drive. Make, model and VIN, for both Minis.
  • My car account. Where the car supports it, Ohme logs into the manufacturer’s service with my credentials to read the charging status. This never actually worked with the first Mini, despite several calls and emails, but they’d have been holding the login all the same.
  • My electricity. Supplier, tariff, meter numbers and, where available, half-hourly consumption from the smart meter. That’s the whole house, not just the car. Every kettle, every load of washing, every time I leave the telly on.
  • My phone. IP addresses, device identifiers and, new in this version, the advertising IDs Apple and Google stamp on every phone.

Mileage isn’t listed. But with five years of charging history and a login to the car, I’d be surprised if they couldn’t work it out.

None of that is sinister on its own. It’s roughly what you’d expect a smart charger to need. Add it all up though, and it’s a detailed picture of my household, held by a company I ended up with because it came bundled with a car.

What changed

The previous policy was dated 4th July 2024. The new one is dated 9th November 2026, and it’s a complete rewrite. Most of it is the same stuff shuffled into tables, with Ireland moved out into its own addendum. Here’s what actually changed.

Gone

  • The promise not to sell. The old policy said: “We will never share or sell your personal data to third parties for marketing purposes.” That sentence has vanished. The new one doesn’t say they will sell your data. It just doesn’t say they won’t any more, which isn’t quite the same thing.
  • A number for how long they keep it. Previously, if your account was closed or went inactive, they kept your data for seven years and then deleted it. Now it’s “a reasonable period after the end of the relationship”. No number, and nothing about deleting it at the end. Reasonable to whom?
  • Limits on suppliers. The old version said suppliers only got the data they needed and weren’t allowed to use it for anything else. That’s gone too.
  • Telling you about changes. Previously any change would be notified. Now they can amend the policy “at our sole discretion” and only have to tell you if they start using your data in a way that’s “significantly different”. To be fair, they did email me this time. Which is how we got here.

New

  • AI. Of course there’s AI. A whole section on it. They use AI tools for document processing, data analysis, customer service routing and chatbots, and third-party AI providers “may process your personal data”. You can ask for a human to review a decision, but only where it “significantly affects you”. Who decides what’s significant isn’t spelled out.
  • Marketing without asking. Email marketing used to need consent. Now existing customers can get SMS or email marketing on “legitimate interests” grounds, which means opt-out rather than opt-in. Post and automated calls are new channels too. Robocalls about my car charger. Lovely. There’s also a paragraph about marketing to people who started signing up and didn’t finish, which manages to say they haven’t consented, and that the legal basis is explicit consent, in the same sentence.
  • Advertising IDs. IDFA and AAID, the identifiers used to track you across apps for ads, are now on the list. I’m struggling to think why my car charger needs to follow me around Instagram.
  • My car login, used for flexibility services. Flexibility services are where Ohme shifts when its chargers draw power, and sells that flexibility to grid operators and energy markets. In 2024 that used my address, location, meter number and tariff. The 2026 list adds car login data, charging data and vehicle information.
  • More stuff, mostly from installation. Photos and videos of the property and fuse box, the electrical installation certificate, the ENA application, meter IDs, crash reports, plus Apple Pay, Google Pay and PayPal details.
  • New places it comes from and goes to. Car manufacturers are now a source. Microsoft 365, ECOES, “flexibility energy markets”, grant administrators such as OZEV, and due-diligence providers in a sale of the company are now named recipients. That last one is worth a moment’s thought.

My favourite bit: section 4.1 tells you which Ohme company is responsible for your data “at [LINK]”. Someone forgot to put the link in before hitting publish. We’ve all been there.

What I’m doing about it

Nothing dramatic. The charger works, the £3-ish fill-ups are the reason I have it, and ripping it off the wall over a privacy policy would be daft. But a few things are easy:

  • Opting out of marketing. One unsubscribe link, or an email to [email protected] . Done before the kettle boiled.
  • Turning off ad tracking on my phone. On iOS, stop apps asking to track. On Android, delete the advertising ID. That deals with the IDFA/AAID collection for every app, not just Ohme’s.
  • Sending a subject access request. Under UK GDPR I can ask Ohme for a copy of everything they hold on me. It’s free, and they have a month to reply. I’m genuinely curious what nearly five years of plugging in a car looks like from their side.

I could also object to the flexibility services processing, but I suspect the answer would be that it’s part of how the smart charging works. I’ll see what the subject access request turns up first, and write that up when it arrives.

The box has been on the side of the house since 2021. It’s about time I found out what it’s been saying about me.

Fancy switching to Octopus? Here’s my referral link . If you sign up we can split £100 with with this link. Or £150 if you’re signing up a business.

[$] Synaptics patent claims stop work on DisplayLink drivers

Linux Weekly News
lwn.net
2026-11-10 10:38:10
Mike Lothian owns a docking station (or dock) that uses a DisplayLink chipset that had, at least in his opinion, subpar performance on Linux. He decided to try improving the Linux driver, with LLM assistance, but ran into one problem that he could not solve—so he asked for help, hoping that Sy...
Original Article
The page you have tried to view ( Synaptics patent claims stop work on DisplayLink drivers ) is currently available to LWN subscribers only. Reader subscriptions are a necessary way to fund the continued existence of LWN and the quality of its content.

If you are already an LWN.net subscriber, please log in with the form below to read this content.

Please consider subscribing to LWN . An LWN subscription provides numerous benefits, including access to restricted content and the warm feeling of knowing that you are helping to keep LWN alive.

(Alternatively, this item will become freely available on November 19, 2026)

Firefox 160 released

Linux Weekly News
lwn.net
2026-11-10 10:37:42
Version 160 of the Firefox web browser has been released. Notable features in this release include the ability to block sites from asking to handle "mailto:" links, ability to play Matroska files with FLAC, MP3, or PCM audio, playback speed controls in the picture-in-picture video player, and a new ...
Original Article

[Posted November 10, 2026 by jzb]

Version 160 of the Firefox web browser has been released. Notable features in this release include the ability to block sites from asking to handle " mailto: " links, ability to play Matroska files with FLAC, MP3, or PCM audio, playback speed controls in the picture-in-picture video player, and a new Mini Window feature that is in early development.


Smart home devices should work without the internet

Hacker News
docodethatmatters.com
2026-11-10 10:25:20
Comments...
Original Article

4506 words 23 min read

Download audio

Scissors cutting an ethernet cable under the words No Internet, No Problem.
Scissors cutting an ethernet cable under the words No Internet, No Problem.

AI;DR: I wrote the first draft, AI helped me edit and rewrite it, and I made the final pass. The rules, setups, and talks are my own.

TLDR; Nothing core in my house depends on a vendor’s server. If the internet goes down, the house keeps running. That’s been rule one for about ten years, and my other rules came out of it. This post has the rules, then both talks I’ve given on home automation, slide by slide.

Why local

My Nest integration worked until Google broke the API. That’s the failure I plan around now. The talks have a few more: a Samsung fridge showing a TLS certificate error on its own screen, and a Camp Chef grill controller that needs Wi-Fi to show you the temperature.

Everything that matters runs on hardware I own. That’s Tasmota on ESP boards, an MQTT broker, and Node-RED on a Raspberry Pi. I do use some cloud services, mostly Alexa and a few AWS ones. Alexa is just another way to flip a switch. If it’s down, the wall switches and the wall dashboard still work.

The rules

From the first talk, restated in the second:

  1. No internet, no problem. Core stuff has to work with the internet unplugged. Alexa can be a way in, but never the only way.
  2. Don’t remove the old way while adding the new one. If someone tapes a wall switch on so a smart bulb keeps power, I skipped this rule.
  3. Be agile. Rooms get used differently and people move in and out, so it all has to be cheap to change.
  4. Check your automations. I once had four scheduled triggers hitting the same garden pump.
  5. Exceptions must be exceptional. I can break a rule, but only for a reason I’d still agree with six months later.

Added after year five, once more people lived in the house:

  1. A cloud device needs an API with logs or it doesn’t get installed. I don’t want a black box in the house.
  2. Config lives in one place instead of five vendor apps.
  3. More than one way in: an app, Alexa, a QR code, or an NFC tag.
  4. If I keep doing the same steps, they become a routine.
  5. Devices talk pub/sub over MQTT instead of point to point.
  6. No batteries unless they last a year or more between changes. Nobody wants to swap a door sensor battery at 2am.

The build I get asked about most is the Tasmota sprinkler controller . It’s in both talks, and so is the garage door setup, which has been running about as long.

Talk One: Home Automation

Home Automation, for fun and convenience

Nobody needs any of this. I do it because I like building things that work in the background, and every automation is a small puzzle with a real payoff when it’s solved.

Connected Everything collage of icons

This is the backdrop for the whole talk. Phones, laptops, tablets, thermostats, and locks all talk to clouds that may or may not be up when you need them. Connectivity is fine. Just know what you’re opting into before you plug it in.

Nest thermostat, Amazon smart plug, and Yale smart lock keypad

Most people start here with a thermostat, a plug, and a lock, and that’s a fine place to start. Each one ships with its own app and its own account.

Privacy, Integration/Flexibility, and Cost triangle

Every device you add lands somewhere on this triangle. A cloud camera is cheap and convenient, and you pay for it with privacy. A switch I flash myself takes more setup time, and in return I can integrate it with anything. I figure out where a device lands before it goes in the cart.

A light switch taped on with a note reading Leave Switch On, This is BAD

Someone (often me) automates a light and then has to tape the wall switch on so the smart bulb always has power. If you’ve ever walked into a room and the switch did nothing, this is why.

Wemo Wi-Fi Light Switch retail box

The better fix for the taped switch is an in-wall Wi-Fi switch like this one. The wall switch keeps working the normal way and I still get a hook to automate. It takes more work to install than a smart plug, but nobody has to retrain their hand.

No Internet, No Problem: scissors cutting an ethernet cable

Rule one, and the one I don’t bend on. If the internet goes down, my lights still turn on.

Must Be Agile: sticky notes on a planning board

Home automation is never done. Rooms get used differently, people move in and out, and new devices show up. Whatever you build has to be cheap to change.

Node-RED flow for Garage Cool Off logic

The garage cooling flow starts from a manual trigger and checks whether the door is closed. From there it opens the door, waits, flips the fan on, or sends a notification if cooling is already running. It’s a small flow and it has kept the garage from baking more than once.

Node-RED garage sensor flow feeding Grafana, plus an Opens counter and On Status chart

The door sensor and reed switch both report into a transform step that sets a global garage-closed flag and logs to Grafana. Below that is the chart from a few real days: 21 opens, with spikes showing when each one happened. Most people skip this part, and it’s the part that tells me whether I left the garage open without opening an app.

Node-RED scheduled injects feeding a Garden Water Pump node

Four scheduled triggers all point at the same pump node. It’s easy to end up with five automations fighting over one device. Every so often I look at the flow and ask whether they still make sense together.

Captain Jack Sparrow meme: The Rules, more of what you'd call guidelines than actual rules

I’ve broken every one of these rules plenty of times. They’re guidelines.

Node-RED logo, a Phillips Hue IFTTT-style applet, and an Alexa routine editor

Here are three ways to say “event in, action out.” Node-RED is my main tool. Alexa routines and IFTTT-style community applets cover the cases where I don’t want to build something from scratch.

MQTT publish/subscribe diagram with a temperature sensor, broker, and two subscribers

MQTT is what keeps the pieces decoupled. The temperature sensor publishes and doesn’t care who’s listening. A phone and a backend system can both subscribe to the same topic, and the sensor needs no extra logic. The sprinkler controller in the Tasmota post is built on the same pattern.

Sonoff Mini Wi-Fi DIY smart switch and a Node-RED fireplace flow

The Sonoff Mini is small enough to hide inside the fireplace’s existing wiring. The flow lets either the dashboard or Alexa flip it. It makes the “memorable automations” list later because a fake fire you can turn on by voice makes a good party trick.

Sprinkler controller wiring, a 3D PCB render, the Tasmota web UI, scheduled nodes, and a bare PCB layout

The whole sprinkler build fits on one slide: the relay and ESP module in the enclosure, the 3D board render, the Tasmota UI with BME280 sensor readings, the Node-RED schedule feeding the pump, and the finished PCB layout. The sprinkler post has the full writeup, including why I picked Tasmota over custom firmware.

The Rules Guidelines Recap bullet list

The recap slide is the whole talk in five lines. I break the first one (don’t introduce a new way while removing the old way) carelessly more often than the others, and I regret it every time. The last one keeps the other four honest. “I was in a hurry” doesn’t count as exceptional.

Memorable Home Automations bullet list

The highlight reel: lights that blink when my heart rate is too low, sprinklers that skip watering if rain is coming, a garage that opens when my phone shows up but the car doesn’t, light and water for an indoor garden, an air quality sensor that kicks on a fan, backyard landscaping lighting, living room LED strips that shift between warm and cool, washer and dryer notifications based on power usage instead of a vendor app, 3D printer status lights, AC and heating monitoring, and a pile of AWS services (Alexa, Polly, S3, IoT, Cognito) stitched together along the way. The Nest integration gets a eulogy: “until Google broke the API.” Every home automation person writes that sentence eventually.

Questions? Feedback!

That was talk one. Almost everything on the “memorable automations” slide later picked up a new failure mode or got replaced, which is why there’s a sequel.

Talk Two: Home Automation, The Sequel

Home Automation, The Sequel

Enough time passed between the two talks that I had a different list of problems to talk about.

Meme: When robots take over the world, Marvin the android saying he could calculate your chance of survival but you won't like it

More devices means more decisions made without me in the loop. That’s a little unsettling, though mostly harmless.

Recap section divider

First, a quick pass back through what talk one covered.

Connected Everything collage, reused from talk one

Same slide as before, with more icons on it now.

A printer-pickup note taped to a pole, a Samsung fridge showing a certificate warning, and a Camp Chef grill WiFi controller

Everyone else is living this too. A fridge’s smart display throws a TLS certificate error. A grill controller needs Wi-Fi to tell you the temperature. Someone taped a note to a pole about an internet-connected printer they forgot to log out of. These are real devices.

The Rules bullet list recap

These are the must and should rules from talk one with slightly tighter wording. I restated them because part of the audience hadn’t seen the first talk.

What has changed? That's why I'm here today

The rules stayed the same. The conditions they had to survive got harder.

Einstein quote: We cannot solve our problems with the same thinking we used when we created them

A lot of my original setup assumed one person lived in the house. When that stopped being true, I had to patch a single-user system into a multi-user one, and the next few slides are what that looked like.

Some of those problems: more foot traffic, more keys needed, longer absences, water flooding

More people means more foot traffic and more physical keys to manage. Longer trips away raised the stakes on anything that could fail without anyone noticing. A water flooding scare is what finally got me to take leak and presence detection seriously.

Captain Jack Sparrow meme again: The Extended Rules, still guidelines

Same joke with a new rule set. The first rules came after year one. These came after year five.

The Extended Rules bullet list

These are rules 6 through 11 at the top of this post. I wrote them after the house went from one person to several.

Examples section divider

Next up are the concrete builds, which is my favorite part of any talk.

A DIY motorized outdoor rig, a UV grow light over plant leaves, and a purple UV strip under cabinets

A motor-and-PVC-pipe rig for outdoor lighting, a UV grow light clipped onto a houseplant, and a UV strip under the cabinets for passive sanitizing. Each one solves a small, specific problem, and that’s where home automation earns its keep.

Sprinkler build collage, reused from talk one

Same sprinkler slide as talk one. It’s back because it’s one of the few builds that never needed a rewrite.

A wall-mounted presence sensor, a robot vacuum on carpet, and an AirGradient air quality sensor kit with dashboard

A sensor that sits on a credenza, a robot vacuum that does the floors without anyone asking, and an AirGradient kit I assembled from a CO2 sensor, a particulate sensor, and a microcontroller, with its own small dashboard. The air quality kit has given me the most peace of mind of anything here.

Wall-mounted tablet dashboard next to a Nest thermostat set to 80

This dashboard has replaced more apps in the house than anything else. It has a garage door toggle, a side door unlock, a front lock toggle, all lights on or off, brightness sliders, a coffee bar color picker, and a warm-to-cool slider for the living room. It all runs on one cheap tablet mounted next to the thermostat, so nobody has to dig through five apps.

A large wall-mounted TV with warm backlighting glowing against the wall

The ambient lighting behind the TV is tied into the same automation system instead of having its own remote. It’s a small change with a big quality-of-life payoff.

A Schlage deadbolt with a physical key and a black touchscreen smart lock with multiple unlock methods

Smart locks came out of the “more people, more keys” problem from a few slides back. The newer lock takes a password, the app, a keycard, or a mechanical key, so everyone in the house can use whatever they’re comfortable with.

Hardware section divider

The next few slides are the parts bin, for anyone who wants to build this themselves.

ESP32 D1 mini board, a dual-outlet smart plug, and a Raspberry Pi 4

The ESP32 D1 mini handles anything custom. The smart plug is the off-the-shelf shortcut when I don’t need custom. The Pi 4 runs Node-RED and Grafana.

A 100ft RGB LED strip kit, a tray of TO-220 power transistors, and relay modules with header pins

LED strips for ambient lighting, power transistors for higher-current loads, and small relay modules so a microcontroller can switch mains voltage safely.

A resistor kit, a DIY wire and cable color kit, and an electrolytic capacitor kit

The rest of the bin: a resistor assortment, color-coded wire so I can trace a circuit later, and a capacitor kit for smoothing and timing.

Software bullet list: NodeRed, Grafana, Tasmota, Telegram, Python, Javascript, Vendor specific Apps

Node-RED handles flow logic and Grafana gives me visibility. Tasmota is the firmware on anything I flash myself, Telegram sends notifications, and Python or JavaScript fills in the glue code that doesn’t fit cleanly into a flow.

Node-RED flow for the Garage tab with sensors, Tasmota topics, Telegram notifications, and light counters

Here’s the garage flow today. The door sensor and reed switch feed a transform into Grafana and a global closed state. Toggle nodes publish straight to Tasmota command topics. Notifications fork to a Telegram sender and an audio chime, and a light-on counter resets at midnight. The editor tabs across the top (Lights, Sensors, Garage, Sprinkler, NFC Tags, Door Lock Security) show how much has grown since the single garage cooling flow in talk one.

Grafana dashboard grid with humidity, temp, dew point, pressure, gas, air quality, energy, opens, and on-status panels

I check this dashboard when I want to know if everything is okay. Humidity, temperature, dew point, pressure, and gas readings are on one side, and energy usage, door opens, and on-status history are on the other. I built it because I got tired of guessing.

UX section divider

Dashboards and Grafana panels work for me. Everyone else in the house just wants the light on.

Close-up of the wall dashboard status screen, a sheet of NFC tags with a QR code, and an Echo Dot

Here’s the “multiple ways to interact” rule in hardware. The wall tablet is for whoever is standing near it. NFC tags and a QR code give a tap-to-trigger shortcut, and the Echo Dot is for anyone who would rather talk to the house.

Tools section divider

Last section: the tools I use to build and debug all of the above.

A soldering iron and stand, a 3D printer mid-print, a digital multimeter, and a precision screwdriver kit

A soldering iron for permanent connections, a 3D printer for enclosures and brackets you can’t buy, a multimeter for when something isn’t working, and a precision screwdriver kit for devices the manufacturer didn’t want opened.

Questions? Feedback!

That’s both talks, ten-plus years apart. The rules barely changed between them, while the list of problems they had to handle kept growing.

A third talk is coming, and this one is built around agentic use cases. The same rules still apply when an AI agent is the one flipping the switches, and I expect a few new ones once it is.

What readers told me

I shared the “no internet, no problem” rule on LinkedIn and asked for the most pointless internet dependency people had found in a device. Dozens of people answered. A Hacker News thread added more. Here’s what came back.

Everyone has one

Most examples were basic functions locked behind an app, an account, or a server:

  • A fridge whose temperature can’t be changed because of a bug in the manufacturer’s phone app.
  • A TV that can’t even switch inputs when the internet is down, and another that has to be signed in before it works as a plain HDMI monitor. One reader’s older smart TV has dead apps but still works as a regular TV, which is how a device should fail.
  • A heating system whose app doesn’t work from the local network.
  • A kitchen vent and a dishwasher that need the internet even when you control them from Home Assistant.
  • A smart plug that can’t be set up on an isolated network.
  • Noise-cancelling headphones that search for a Bluetooth device forever, so you can’t just turn on the noise cancelling.
  • Synthesizers and MIDI keyboards that need a cloud login for first use or firmware updates.
  • A meat thermometer that only worked through its app and stopped working when the company went out of business.

The meat thermometer bothers me most. The hardware outlived the company, and it stopped working anyway.

Rules readers added

  • Offline first, with the internet for extras. A device should do its main job on its own.
  • Treat every third-party dependency as a risk. APIs change, so plan a local fallback or a clear degraded mode. One mobile developer works the same way: the core action works offline or from cache, and only the extras wait for a connection.
  • Decide what must work offline. My answer is turning things on and off, temperature and safety controls, and anything a guest has to use without learning an app. As one reader said, if a visitor can’t turn something on or adjust the temperature without an app account, the design has failed.
  • A stricter version of my first two rules: everything core works with the Wi-Fi or the automation server shut down, and smart features never take away the dumb ones. The wall switch should control the light directly and let automation flip it. A switch that only sends a request to the automation fails. That reader says my sprinkler controller fails this bar too. The only sprinkler controller they’d found with a local API and full control on the device itself was RainMachine, which is gone.
  • Clean up when you throw things away. Remove a connected printer from your account first. An abandoned connected device can be an easy way in for an attacker.

Practical tips

  • Use local protocols. One reader recommends Zigbee and Z-Wave over Wi-Fi, because a switch that doesn’t need the cloud tends to behave the same year after year. Another uses Zigbee for the smart plugs that can’t be set up without internet.
  • Let an LLM find the firmware. One reader buys the cheapest hardware that does the job, ignores reviews that complain about the app, and asks an LLM for local-first custom firmware once it arrives. That has worked for their switches, a thermostat, an air quality monitor, a thermometer, and a window fan. They’d have paid about 2.5x for hardware that was local out of the box.
  • Old Nest thermostats have a way out. No Longer Evil is open source firmware for Nest Gen 1 and Gen 2 thermostats.
  • Smart TVs can be tamed. Reset the TV and never connect it to the network, and the input problem goes away.
  • Remote access is the cost of staying local. I use Tailscale on the router and keep the individual devices off the tailnet. One reader ran OpenVPN on OpenWrt, which worked but felt clunky, and is now trying Tailscale.
  • There’s a gap to fill. One reader would happily pay for a pre-built, open “works with everything” Raspberry Pi image with MQTT. DietPi and OpenWrt come close and have a small footprint, but you need some understanding to get going. Another wanted a hub that ships with the house, like a water heater or a router. Home Assistant sells hub hardware that’s close to that.
  • Right to repair is the bigger fight. Readers pointed to the right-to-repair movement and groups like the FULU Foundation , which work to keep companies from locking you out of what you bought.

Counterpoints

Connectivity has real uses. A connected meat thermometer lets you watch the game while the steak cooks. The same reader also had an oven decide to update its software in the middle of cooking. One reader pointed out the business model behind all of this: companies would rather sell you a service than a product. Another expects the shift away from internet-connected devices to come from resilience worries rather than consumer complaints, since enough connected homes make a target. And one skips connected appliances entirely, keeping only computers and phones online.

Devices I’ve used

(This section has Amazon affiliate links. If you buy through them, I may earn a small commission at no extra cost to you.)

These are the parts from my home automation builds, grouped by project.

Sprinkler controller

Gear Purpose Buy
HiLetgo ESP8266 NodeMCU board (3 pack) Wi-Fi microcontroller that runs Tasmota Amazon
SSD1306 OLED screen Status display for the sprinkler state Amazon
Inkbird SSR-40DA solid state relay Switches the 24 VAC sprinkler valve Amazon
BME280 sensor Temperature, humidity and pressure Amazon
24 VAC power supply Powers the sprinkler valve Amazon

Lights, switches and plugs

Gear Purpose Buy
Martin Jerry smart dimmer switch (Tasmota pre-flashed) Wall light switch that runs Tasmota out of the box Amazon
Martin Jerry humidity fan switch Runs the bathroom fan when humidity gets too high Amazon
Sonoff S31 smart plug Power watchdog for the cable modem Amazon
Serial-to-USB adapter Connects an ESP8266 to your PC for flashing Tasmota Amazon

Garage door

Gear Purpose Buy
Raspberry Pi 3 Runs Docker and the web API Amazon
SunFounder 2-channel 5V relay module Simulates the button press to toggle the door Amazon
LiftMaster wired control panel (78LM, replaces the 41A5273-1) Bypasses the anti-tamper wiring Amazon

Around the house

Gear Purpose Buy
GL.iNet Flint 2 router (GL-MT6000) Runs OpenWrt and an MQTT broker locally Amazon
Cheap tablet Mounted on the wall as the dashboard Amazon
Lefant robot vacuum Cleans the floors Amazon

OurCal

Daring Fireball
ourcal.com
2026-11-10 10:15:17
My thanks to OurCal for sponsoring last week at DF. You ever have a discussion that starts with “I didn’t see you put that on the calendar”? Could be with your colleagues, could be with your family. But the problem is familiar: Shared calendars solved scheduling, not communication. OurCal connects ...
Original Article

Apple Editors’ Choice Featured Recently on the App Store

Shared calendar. Meet messenger.

The shared calendar built around messaging. Group calendars for families, couples, friends, and colleagues. Always protected with End-to-End Encryption .

Download OurCal on the App Store Get OurCal on Google Play

“The problem with sharing calendars isn’t productivity. It’s communication . So we built a shared calendar where every action is a message.”

Ryan Brodie Ryan Brodie Founder, OurCal

More than a planner

A shared space where your group actually communicates.

Chat in every event

Talk about the plan inside the plan .

Every event has its own thread. Share photos, files, and notes without leaving the event. React, reply, and quote just like a messenger, but everything stays in context instead of scattered across WhatsApp, iMessage, and email.

Learn more about event chats

An OurCal event’s chat on iPhone

Automatic change tracking

Someone moved the dentist? You’ll know .

Every change posts a before-and-after update automatically, and reminders reach everyone who needs them. No more “wait, did you move that?” buried in a group chat.

Learn more about event alerts

iPhone lock screen showing OurCal calendar-change notifications

Colour-coded calendar views

A busy week that reads at a glance .

Every member gets a colour. See your kids’ activities, your partner’s shifts, and your own schedule in a single view, then pinch to zoom between overview and detail.

Learn more about calendar views

OurCal’s colour-coded week view on iPhone

Sync all your calendars

Google, Apple, and Outlook in one place, plus subscribed calendars like sports fixtures and school term dates. See personal and shared side by side: no more double-booking .

Smart event creation

Type “Dentist Tuesday 3pm for an hour” and it’s done. Reminders, todos, and repeating events too, all in natural language. On-device AI , nothing sent to the cloud.

Groups for your whole life

Home, work, school, social. Each group gets its own calendars, members, and chat. One app, every group .

Share shifts and rotas

Nurses, paramedics, hospitality, police: share your rota so friends and family never plan over a working day.

OurCal’s colour-coded shared calendar in month view on a MacBook OurCal’s colour-coded shared calendar in month view on an iPad OurCal’s colour-coded shared calendar in month view on an iPhone OurCal’s colour-coded shared calendar in month view on an Android phone

Every device

Yours on iPhone.
Theirs on Android.

Truly native on iPhone, iPad, Mac and Vision Pro, and just as at home on Android. Whatever your group carries, everyone stays in sync.

Encrypted. Everything. Always.

Privacy isn’t a feature.
It’s the foundation .

The only shared calendar with ANSSI-certified End-to-End Encryption.

ANSSI-certified E2EE

Every profile, group, calendar, event, message, and file is End-to-End Encrypted by default, certified by France’s national cybersecurity agency.

No ads. No tracking.

You pay for OurCal, so your data stays yours. We never sell it, mine it, or show you ads. Ever.

You stay in control

Advanced sharing controls let you invite by private link and stop sharing at any time. Your group, your rules.

Real groups, real stories

Organising life together, everywhere.

Their photos stay locked because everything in OurCal (profiles, calendars, events, and messages) is protected with End-to-End Encryption .

Read all stories

FAQ

Frequently asked questions.

What is End-to-End Encryption?

It means your calendar can be read by only you and the people you share it with. The keys never leave your group, so no one else can read your data. Not even OurCal. Read more

Is OurCal’s End-to-End Encryption certified?

Yes. Our encryption is provided by Seald, whose technology is certified by ANSSI, France’s national cybersecurity agency. Read more

Do we each get our own account?

Yes. Everyone gets their own account, and you share calendars by joining the same group. Read more

Who can join a shared calendar?

Anyone you invite. Share your group’s private invite link and they’ll be guided through joining. Groups support 2 to 100 members. Read more

Can I use OurCal with multiple different groups?

Yes. Home, work, school, social: create or join as many groups as you like, each with its own calendars, members, and chat. Read more

Can I share different calendars with different groups?

Yes. Calendars belong to a group, so each group only ever sees its own calendars. Read more

How do I set up my family, couple, or group in OurCal?

Download OurCal, tap Create Group, and share the invite link. You’ll be up and running in under a minute. Read more

Which shared calendar app is best for a couple?

For two people on different phones, OurCal is built for exactly that: a chat on every event, End-to-End Encryption, and one subscription covering you both. Compare the best shared calendar apps for couples

How do I contact OurCal support?

From OurCal’s Settings, tap Help & Feedback, then Request Help. We’ll get back to you quickly. Read more

Show HN: Valencia, Spain in Sim City/Isometric View

Hacker News
tinyvalencia.com
2026-11-10 10:12:16
Comments...
Original Article

Tiny València

An isometric pixel-art map of València, in the spirit of SimCity and of Isometric NYC . Every building is a real one, drawn from above at the same angle, block by block.

The whole municipal term is painted, from the huerta to the Albufera, except a few small huerta exclaves where there's no 3D imagery to paint from.

How it's made

Real 3D city data is rendered from a fixed isometric camera. An image model trained on a hand-picked pixel-art style then repaints it, tile by tile, each tile continuing its painted neighbours so the city stays seamless. The sea, the port basins and the Albufera are drawn in the same style.

Getting around

  • Drag to move, scroll or pinch to zoom, double-click to zoom in
  • R somewhere random · H whole map · F full screen · / search · G play
  • The address bar always holds the current view, so any link you copy opens right here.

Data

Buildings © Dirección General del Catastro · Aerial photo & terrain © IGN (PNOA, MDT05), CC BY 4.0 · Roads, boundary, coast & search © OpenStreetMap contributors, ODbL · 3D reference: Google Photorealistic 3D Tiles via Cesium ion.

Our Lefts: Lessons from the Socialist and Communist Parties

OrganizingUp
convergencemag.com
2026-11-10 10:05:17
Disclosure: This post contains affiliate links to Convergence’s Bookshop. 10% of purchases made through our bookshop support our movement media work. Featured images by Elizabet Wendt It certainly is the worst of times–far too many crises and crimes to list here, horrifically dangerous, no center ho...
Original Article

Nvidia shaken by scandal amid wider political new order for big tech

Guardian
www.theguardian.com
2026-11-10 10:04:38
A scandal tests Nvidia’s dominance as tech billionaires seek to mend ties with Democrats after the midterm electionsThis was originally published in TechScape, a newsletter about how technology shapes our lives. Sign up to receive it hereToday in tech, we’re talking about Nvidia’s salacious scandal,...
Original Article

Today in tech, we’re talking about Nvidia ’s salacious scandal, tech tycoons trying to reconcile with Democrats, and what billionaires should spend their money on if not elections.

Cracks appear in Nvidia’s dominance

On the opening night of Web Summit in Lisbon, the Nvidia CEO, Jensen Huang’s admission that he had an affair with a Chinese datacenter executive suspected to be a spy for Beijing hit the main stage. The news broke less than 24 hours prior, and the reaction was surprising.

Matthew Prince, CEO of Cloudflare, broadened the implications of the scandal from Huang’s personal life to Nvidia’s market dominance.

“Whatever Jensen did in his personal life, that’s very salacious. In the longer term, whether Nvidia is the hero or the villain, we’ll be asking: Were the things they did to cement their market position … just financial engineering?” Prince said in front of tens of thousands of onlookers.

Nvidia’s essential role in the AI boom as the world’s premier chipmaker had given it a Teflon reputation in Silicon Valley . It served as both a bank – providing loans to its own buyers to purchase its chips – and hardware provider. Prince credited Huang for doing “a lot to cement the AI ecosystem”.

Likewise asked to respond to the news, Richard Socher, CEO of the four-month-old AI startup Recursive Superintelligence, simply said he was “grateful to have Jensen in my corner”.

Prince responded immediately: “That’s captured interest!” After all, Nvidia participated in Recursive’s $500m investment round, announced in April. The chipmaker has faced criticism over its circular financing deals, but the superiority of its hardware has for many years allowed it to make strong alliances within Silicon Valley that have warded off lasting damage.

US intelligence agencies are already scrutinizing Huang. Judging by Prince’s remarks, Silicon Valley may soon do the same.

Jensen Huang, family man; Nvidia, family business.

Man in glasses presses lips together
Nvidia’s board of directors has launched an independent investigation into reports that Jensen Huang was targeted by a foreign intelligence operation, after he admitted he had a relationship with a businesswoman whom US intelligence services suspect is a spy for China. Photograph: Ritchie B Tongo/EPA

My colleague Johana Bhuiyan analyzes Huang’s confession and what it might mean for one of the world’s most valuable companies, which is bound up with his family to an unusual degree for Silicon Valley:

For more than 30 years, Jensen Huang has been the seemingly unshakable public face of Nvidia. He co-founded the company as a young engineer in 1993 and oversaw its growth into a multitrillion dollar chipmaker and bellwether of the AI industry at large.

He’s also made it a family business. His children, Madison and Spencer, have taken leadership roles at the firm. While not a company executive, his wife, Lori Mills Huang, leads the family foundation which, as of 2024, controls over 60m Nvidia shares worth billions. The two married some 40 years ago. During public appearances, he’s fond of telling the story of how they met in college.

But Huang’s image as a family man has been shattered as of Sunday. He admitted in a letter to employees on Sunday that he had been having an affair. Nvidia’s board of directors have now launched an independent investigation about the national security concerns surrounding Huang’s relationship.

“Throughout my life, my family has given me love and support,” Huang wrote in his letter. “They deserve my honesty and loyalty. Instead, I let them down and damaged the life we built together. I take full responsibility for what I did and the hurt I caused, and I accept the criticism that comes with it.”

skip past newsletter promotion

On one hand, Huang’s affair is not just a matter of morals or ethics, as there are potential national security concerns. On the other, Huang is core to the DNA of Nvidia, which in turn is the bedrock of the entire AI industry – an industry upon which the US economy relies greatly. Huang himself may be too big to fail.

Investors are doubting what was once seen as an unstoppable juggernaut. Nvidia shares fell 7.5% as soon as the stock market opened, wiping over $330bn off the company’s value.

Tech barons attempt reconciliation after blue wave. Will newly powerful Democrats accept?

photo of tech leaders
Guests including Mark Zuckerberg, Jeff Bezos, Sundar Pichai and Elon Musk, arrive before the 60th presidential inauguration in the rotunda of the US Capitol on 20 January 2025. Photograph: Julia Demaree Nikhinson/Reuters

In the wake of Tuesday’s blue wave, Silicon Valley is attempting to reconcile with the new power brokers in the US.

Tech’s tycoons spent the last two years cozying up to Donald Trump. On Thursday, Elon Musk sang a different tune. After railing against Texas Democrat James Talarico with jibes like “He’ll trans your kids” and spending tens of millions to elect his opponent, Musk responded kindly when the senator-elect called him a “great innovator” on a podcast. Musk tweeted: “Nice of him to say that”. How cordial! It’s a far cry from the extreme and unrelenting partisanship that Musk has hawked for months leading up to the elections.

Venture capitalist Chamath Palihapitiya, host of the influential All-In podcast, tweeted on Sunday: “When I’m wrong, I’m wrong … This was a complete and total repudiation about the state of the economy. The economy is broken.” His message sounds much closer to affordability-obsessed Democrats.

Democratic lawmakers are putting out statements that any reconciliation by the tech oligarchy remains largely one-sided and transactional. Newly in-control Democrats do seem to differ in their views on the best strategy for dealing with the conservative problem of Silicon Valley. Members of Congress are eager to haul in tech CEOs for grillings and pass AI safety laws. Newly elected governors campaigned on promises of moratoria on datacenter construction.

It is not clear which is the best path forward for Democrats as they assume power. The US stock market relies heavily on the AI industry’s growth. Hamstringing that industry with bans on new datacenters and legislation that cracks down on AI model development risks sending the economy into a backslide. However, the voting public wants to make a public example of AI CEOs, who are despised on both sides of the aisle despite their alliance with Trump and the Republican elite.

Ransomware recovery is now a client retention metric

Bleeping Computer
www.bleepingcomputer.com
2026-11-10 10:01:11
Recovering from ransomware doesn't guarantee an MSP will retain its clients, especially when delays, poor communication, and unexpected costs undermine trust. Kaseya examines how disconnected recovery tools create these problems and how integrated workflows can improve response times, transparency, ...
Original Article

Ransomware recovery

The ransomware attack is over. Your team has restored the client’s data, brought systems back online and put business operations back on track. From a technical standpoint, the recovery was a success.

But the client still has questions. Why did updates go quiet for two days? What drove the recovery costs up? And where did the 31 hours of emergency labor on the invoice come from?

Recovering from ransomware is only part of the job. Clients also need to know what happened, what recovery involved and what it cost them. When communication falls short or unexpected charges appear, even a technically successful recovery can leave clients questioning the value of their MSP relationship.

The disruption may be behind them, but their doubts can carry into the next renewal conversation.

The trend: Slow, fragmented recovery erodes trust and renewals

Ransomware recovery can take days, even when teams have backups and a response plan in place. According to industry reports, only 16% of affected organizations fully recovered within a day . Over half (55%) recovered within a week. For businesses that depend on their systems to serve customers and generate revenue, every additional day of disruption carries a cost.

The stakes extend to the MSP, too. Kaseya’s 2026 Cybersecurity Outlook report found that 12% of MSPs lost clients following security incidents , with ransomware, account takeover and business email compromise among the main reasons.

When recovery involves delays, fragmented efforts or gaps in communication, clients struggle to understand what is happening and when they can expect normal operations to resume. They may also question unexpected costs or wonder whether their provider has the situation under control.

Clients expect cyberattacks to happen, but they also expect their MSP to respond quickly, coordinate recovery and keep them informed. When those expectations go unmet, a technically successful recovery may still leave clients questioning whether they should renew their contracts.

A successful recovery depends on both the technical response and the client experience. MSPs that set expectations early, communicate consistently and explain costs before they become surprises have a stronger chance of preserving client trust long after the systems come back online.

Where your recovery process breaks down

Most MSPs have skilled people. The trouble starts when those people work across disconnected tools in the middle of a crisis.

Tool sprawl slows everyone down

Backup, monitoring, ticketing and billing live in separate consoles. Your techs spend incident hours piecing together context instead of restoring systems.

Handoffs break

An alert fires in one tool, a ticket opens in another and a restore job runs in a third. Nothing links them, so no one can say what the attack touched or what’s still down.

Billing falls through the cracks

Emergency labor, restore time and after-hours work often go untracked. Someone reconstructs those hours from memory days later. You either lose margin or send an invoice the client doesn’t recognize, and you do it at the worst possible time.

Client updates depend on who’s free

Without a single ticket trail, communication comes down to whoever has a spare minute. Some clients get a call every few hours. Others hear nothing until the work is done.

Each of these problems looks small by itself. Together, they turn a recoverable incident into a trust problem.

5 signs your recovery process is costing you client trust

  1. Clients chase you for updates . They have to ask what’s happening instead of hearing from your team.
  2. Your team scrambles across tools. Technicians waste valuable recovery time piecing together information from disconnected systems.
  3. No one owns the full picture. Handoffs leave gaps in who knows what’s restored, what’s still down and what needs attention.
  4. Recovery bills come as a surprise. Emergency labor and after-hours work appear on invoices without clear explanations.
  5. Recovery ends without clear answers. Clients are left unsure what happened, what it cost or what you’ll do to prevent a repeat.

What good recovery looks like for an MSP

Strong recovery runs on one timeline and one source of truth. Everyone on your team sees the same facts, so your client hears the same story no matter who calls. Updates go out on a schedule you set, before the client asks.

When the incident closes, the invoice matches the work, because your team logged the work as it happened.

Track three numbers to see how you’re doing:

  • Time to first client update: How long after detection does the client hear from you?
  • Time to restore: How long until their critical systems run again?
  • Time to invoice: How fast can you send an accurate bill after closing the incident?

If any of these takes too long, you have a process gap that clients will notice. Closing those gaps takes more than working harder during an incident. It takes tools that share data from the start.

The fix: Unifying RMM, PSA and BCDR with Kaseya Trifecta

The 2026 Kaseya Cybersecurity Report found that two factors supported faster incident recovery : well-trained internal IT or security teams (35%) and integrated security and IT management tools (18%).

Kaseya Trifecta puts RMM, PSA and BCDR in one connected platform. The idea is simple. When your monitoring, ticketing and recovery tools share a workflow, your team stops stitching context together and starts fixing the problem.

Here’s how it maps to the breakdowns above:

  • Fragmented context: RMM, PSA and BCDR run on one workflow and one data set, so your techs see the full picture in one place.
  • Slow handoffs: Recovery events tie directly to tickets and endpoints. You know what’s affected and what’s restored without chasing updates.
  • Billing blind spots: Time and labor land in the ticket as the work happens, then flow to billing. Your invoice reflects what your team did.
  • Inconsistent updates: One auditable incident record gives every team member the same facts. Your client gets consistent communication, whoever is on shift.

This matches what the report found. Teams that recover quickly pair skilled people with tools that connect. Trifecta gives your people that connection.

Keep the client, not just the data

Surviving the attack is the baseline. Your clients expect it. What they remember is whether recovery felt organized, transparent and fair.

Faster resolution gives you the foundation for all of that. It shortens downtime, makes your updates credible and keeps your invoices accurate. Those benefits help protect renewals long after the incident closes.

Want to see how MSPs cut resolution times? Download the AI Playbook: AI in Action: How MSPs Achieve Faster Resolution Times.

Sponsored and written by Kaseya .

Beyond the compiler: Making IBM i run modified native code - Program Validation Value

Lobsters
blog.silentsignal.eu
2026-11-10 09:48:26
Comments...
Original Article

Why this matters

IBM i does not treat an application program as a normal file that happens to contain POWER instructions. A compiler produces Machine Interface (MI) code, IBM i’s stable instruction-level boundary, and the system translates it into a native form. The generated native code contains checks that support the IBM i object and tagged-pointer model.

Changing those instructions can make IBM i execute behavior that was not present in the MI input. Earlier Below MI research examined the wider consequences on IBM i V7R4. Here I focus on the IBM i 7.5 Program Validation Value (PVV) , a 32-byte value stored with a saved program.

I reconstructed the 32-byte PVV calculation and matched all 1,223 known-valid values. The reconstructed calculation derives its HMAC key entirely from saved program attributes and fixed Licensed Internal Code (LIC) constants; it contains no separate secret for origin authentication. IBM i applies separate digital-signature checks where required. In controlled USER-state programs—the ordinary, non-SYSTEM execution mode—recalculating PVV and the separate save-file checks allowed selected native instruction changes to survive restore and resave. A disposable CrackMe produced the expected changed output, demonstrating execution.

USERB1, an ordinary test account without special authorities, restored a USERB1-owned, PVV-repaired MEMDUMP program through IBM’s Restore Object List ( QSRRSTO ) API, and a resave preserved its modified native instructions. Its executable payload matched byte-for-byte the payload used in a controlled runtime test. In that test, MEMDUMP ran as USERB1 and read from a known-address USER-domain buffer in a cooperating job running under QSECOFR, IBM i’s security-officer profile. Other controls showed IBM i rejecting unsigned SYSTEM and INHERIT program-state variants and enforcing the SYSTEM-domain access boundary.

My previous article covered the outer save file (SAVF) container: its per-record checksums and global checksum. During restore, IBM i also calculates PVV and compares it with four values stored in the saved program.

The USER-state controls ran under the test system’s existing restore-policy system values ( QVFYOBJRST=3 , QFRCCVNRST=1 , and QALWOBJRST=*ALL ) at QSECURITY 40 , which enforces resource security and integrity protection.

Program validation and research approach

SAVF record and global checks establish container consistency; PVV establishes consistency with selected serialized program data. LIC copies the 32-byte descriptor unchanged into the HMAC key object. Every descriptor byte comes from saved program attributes or fixed LIC constants, and the recovered path contributes no additional secret. A party with the serialized program and the reconstructed algorithm can therefore derive the key and recompute PVV; a match establishes consistency, not trusted origin. Restore authorization and system policy still govern the operation, while digital signatures authenticate origin where required.

A program has separate state and domain attributes . Its execution state is USER, SYSTEM, or INHERIT; INHERIT uses the caller’s state. The program object itself has a USER or SYSTEM domain, and that saved attribute contributes separately to the PVV descriptor. Other objects accessed by the executing code also have domains. The USER domain is a storage-domain classification, not a user identity or ownership boundary. At QSECURITY 40, USER-state code cannot directly access SYSTEM-domain objects.

The algorithm at a glance 

PVV = HMAC-SHA-256(descriptor, canonical_message)

PVV is calculated in four steps for the supported program format:

  1. Walk the saved program graph, select the protected byte ranges, normalize saved pointers, and put the ranges into canonical-message order.
  2. Build a 32-byte descriptor from program attributes and constants chosen by the recovered state, domain, version, release, and mode selectors.
  3. Use the descriptor as the HMAC key and the canonical message as the input to HMAC-SHA-256.
  4. Split the result into four 64-bit values and compare them with the stored values.

Leif Svalgaard’s earlier PVV work was a clue

Leif Svalgaard described the earlier mechanism in Chapter 15, “Program Validation Value,” of AS/400 Machine Level Programming . His public program index also lists MIPGMVV , which calculates an eight-byte value from program attributes. I reproduced his published example. Its four selector constants do not match the current LIC descriptor constants in either byte order, but both designs select values according to state and domain. That similarity pointed me toward the current 32-byte validation route.

Finding the validator

I started with CHKOBJITG , the IBM i command that checks object integrity.

For a program, CHKOBJITG reaches the IBM-supplied QSYS/QSYCHKIT program. Its native procedure QSYINTEGRI::checkPgmMod contains this sequence, copied from the retained IBM Display/Alter/Dump (DAD) output: 

2B463690C5 0052B4  0000D4  62E30000  ORI 3,23,0
2B463690C5 0052B8  0000D8  39400103  ADDI 10,0,259
2B463690C5 0052BC  0000DC  44000141  SCV 10

ADDI loads selector 259 into r10 ; the following SCV 10 , Supervisor Call Vectored, enters dispatcher vector 10. The 10 in the mnemonic identifies the vector, while the value in r10 selects the service. That combination led to this observed call path: 

QSYCHKIT/QSYINTEGRI::checkPgmMod
  -> #cfmir
  -> #dotssob
  -> VBNTSSOB::#bntssob
  -> VBNTSSOB::vbnskew4
  -> VBNNAPE2::vbnspnt2

The live capture tied the path to the loaded address of my CALLAES test fixture. I matched the remaining code against the IBM i 7.5 LIC from installation media by procedure name, normalized instruction sequence, call topology, constants, and tables. The live instructions and invocation frames identify the observed CHKOBJITG route; the build-matched LIC supplies the complete procedure bodies. For both VBNTSSOB and VBNNAPE2 , the installation addresses were 0x3000 above the captured live addresses and the normalized bodies agreed; that displacement is evidence for this match, not an IBM i addressing rule.

Reconstructing PVV

My parser supports uncompressed IBM i 7.5 program ( *PGM ) and service-program ( *SRVPGM ) items whose record graph, section descriptors, and 40-bit segment identity plus 24-bit in-segment pointer mapping follow the recovered layout. It rejects other layouts before calculation instead of trying models until one happens to match the stored result.

The stored result

vbnspnt2 writes 32 calculated bytes, loads them as four 64-bit doublewords, and compares them with four values stored in different parts of the program graph. Any mismatch returns false.

For CALLAES , the item starts at SAVF logical offset 0x4000 . The item-relative offset must first be converted to a SAVF logical offset. That logical coordinate counts only 512-byte payloads; the physical coordinate also counts each 16-byte record trailer: 

logical = 0x4000 + item_offset
physical = (logical // 512) * 528 + (logical % 512)

Applying both stages gives these four locations:

Part Item offset Logical SAVF offset Physical SAVF offset Stored bytes
0 0x22C0 0x62C0 0x65D0 E8DC295506AFD7E6
1 0x4B78 0x8B78 0x8FC8 9794394254EF4224
2 0x21F8 0x61F8 0x64F8 8EAD0FB7B8C3AB42
3 0x2648 0x6648 0x6978 307B34648AE1C331

In comparison order, the stored PVV is: 

E8DC295506AFD7E69794394254EF4224
8EAD0FB7B8C3AB42307B34648AE1C331

Building the canonical message

LIC follows a graph of program headers, components, procedure records, native sections, counted arrays, and optional records. It adds selected byte ranges, not the complete program item.

Saved pointers cannot be hashed directly because their segment identities may change after restore. LIC replaces them with a stable segment number and the offset inside that segment. For example: 

saved pointer:       10804C6DE6001520
segment number:                       1
segment offset:                  0x1520
canonical value:    0000000100001520

LIC also changes the order of some data. Appends shorter than 0x400 bytes are copied into one owned stream. Appends of 0x400 bytes or more remain separate entries. The final HMAC message contains the complete copied stream first, followed by the retained entries.

Here, an aggregate entry is one buffer passed to the HMAC update path.

If the logical append order is a short span A , a retained span B , and a short span C , the message order is A || C || B .

For CALLAES , 65 logical appends became three aggregate entries:

Entry Length Message offset
copied spans 0x1234 0x0000
retained span 1 0x0610 0x1234
retained span 2 0x0870 0x1844

The final message length was 0x20B4 , or 8,372 bytes.

Building the descriptor

The descriptor contains four 64-bit values:

  1. one value formed by joining two four-byte program header fields;
  2. a fixed constant selected by state, domain, and version class;
  3. a constant selected by the target release;
  4. a constant selected by the recovered mode.

“Version class” and “mode” are names for reconstructed selector inputs. I do not present them as documented SAVF field names.

Within the retained fixtures, the recovered version_kind=0x0028 input selects one version class by contributing 0 to the table index; other observed values, including CALLAES ’s 0x000A , contribute 1. With CALLAES ’s USER state and domain, that selects 2E9132CE813F75B2 . The mode byte independently selects the fourth 64-bit descriptor value: mode 1 selects 3809245098034DDE , while mode 2 selects 3809745098034DDE .

Canonical program-state values are 0x0001 for USER, 0x0080 for SYSTEM, and 0x0000 for INHERIT. For descriptor selection, the state selector treats 0x0080 as SYSTEM, 0x0000 as INHERIT, and every other value as the remaining selector class. The domain selector tests the least significant bit of program base byte +0x20 —bit 7 in IBM’s MSB-0 numbering. In the CALLAES fixture the byte was 0x80 ; that bit is clear, so the program domain was USER. A byte of 0x81 selects SYSTEM program domain. This byte is separate from the 16-bit state value 0x0080 .

For CALLAES , the selected descriptor was: 

C884EBDE4ED4E62B2E9132CE813F75B2
83CF578390004BA13809245098034DDE

The calculation selects these fixed tables without consulting the stored PVV.

The cryptographic operation

The lower LIC code creates a key object, copies all 32 descriptor bytes into it, and feeds each aggregate entry to a message digest object. The next layer implements the standard HMAC construction with a 64-byte block, the 0x36 inner pad, the 0x5C outer pad, and SHA-256.

The recovered calculation maps directly to Python’s standard HMAC implementation: 

import hashlib
import hmac

calculated = hmac.new(
    descriptor,
    canonical_message,
    hashlib.sha256,
).digest()

For CALLAES , it returns the exact 32 stored bytes shown above.

Offline validation

I applied the recovered model to IBM-supplied save-file items and disposable programs and service programs. The corpus measures agreement and structural coverage over supported rows, not blind holdout or live restore and execution tests. The final totals were: 

known valid exact matches:        1,223
deliberate mutation fixtures:        16
successfully parsed rows:         1,239
unsupported program items:           17
total attempted items:            1,256
distinct structure profiles:      1,003
unexplained mismatches:                0

A structure profile fingerprints object type, release and version selectors, mode, record shapes, and canonical-chunk construction without including the protected byte values. The 1,003 profiles occur among the 1,223 known-valid rows; repeated saves or equivalent layouts can share one. The 16 deliberate mutation fixtures remained invalid. The parser rejected another 17 items before calculation: seven had malformed section descriptors or descriptors that did not expose the validated 40-bit segment and 24-bit offset mapping, and ten contained pointers that could not be mapped unambiguously to a recovered segment. These are unsupported structures, not unexplained PVV mismatches.

I produced these results with the local pvv-ibmi tool bundle. pvv_demo.py is its command-line entry point, savf_checksum_demo.py implements the SAVF checks, and scripts/reconstruct_v7r5_pvv.py parses the program graph and calculates PVV. I plan to publish the bundle and its usage notes in the Silent Signal IBM i PVV repository .

The --table argument specifies sandbox.ser , which contains the lookup table used for the SAVF global checksum. I described its extraction in my previous SAVF checksum article .

The tool’s two main commands are: 

python3 pvv_demo.py --table sandbox.ser check input.FILE
python3 pvv_demo.py --table sandbox.ser fix modified.FILE repaired.FILE

check verifies the SAVF checks and PVV. fix calculates PVV, writes the four stored values, repairs the separate SAVF checks, and verifies the output in a new file while preserving the intended native change.

Live restore controls

The offline matches establish the calculation. The following controls test how restore consumes the stored value, whether edited native code survives, and whether IBM i executes the changed control flow.

A stale stored value

In the P7QPM831 test program, I changed one stored PVV byte but left the protected program data unchanged. I repaired only the SAVF checks. CPC3703 denotes normal restore completion in the baseline and corrected controls.

Input PVV SAVF checks Result
baseline valid valid CPC3703 , process status 0
one stale byte invalid valid CPF3848 , CPF3773 , process status 255
corrected value valid valid CPC3703 , process status 0

The stale restore created an object, which I then saved again. The calling process returned status 255, while the substituted restore messages recorded the actual object counts: 

CPF3848: 1 security or data format changes occurred.
CPF3773: 1 objects restored. 0 not restored.

The resaved object still contained the incorrect stored value. Writing the independently calculated value restored normal completion. The mismatch was therefore detected and changed the command outcome, but did not prevent object creation in this control.

A native change that survived

The RISCPVV1 test program measured native-code preservation without changing behavior. I replaced one instruction with a different instruction that copies the same register value: 

before  60860000  ORI 6,4,0
after   7C862378  OR 6,4,4

The saved creation material—the input IBM i can use to recreate native code—remained unchanged. To distinguish preserved native code from code recreated from that material, I repaired PVV and the SAVF, restored the object, and saved it again. The executable payload was eight native records joined in graph order after removing each record’s final eight-byte saved-space pointer, which is metadata rather than executable payload.

All 1,120 executable bytes matched between the modified and resaved streams; the original differed at the edited instruction. The 40-bit segment-identity prefixes within those trailing pointers changed as expected when IBM i materialized the object; their 24-bit in-segment offsets did not. The executable payload and repaired PVV remained unchanged.

CrackMe: a branch that changed behavior

PVVPASS , which I call CrackMe here, provided the visible control. This disposable fixture compared its argument with silentsignal , printed pwd is ok for a match, and printed wrong otherwise.

The retained source was: 

#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
    if (argc > 1 && strcmp(argv[1], "silentsignal") == 0)
        puts("pwd is ok");
    else
        puts("wrong");
    return 0;
}

I compiled it as a native Integrated Language Environment (ILE) C program with DBGVIEW(*NONE) , OPTIMIZE(40) , and ACTGRP(*CALLER) , then saved it without compression.

The relevant saved instructions are below in reconstructed DAD style. Register 5 holds the current input byte. Register 0 holds the current expected byte. 

1E75B1F2E2001F78  2C250000  CMPI   0,1,5,0
1E75B1F2E2001F7C  397E0010  ADDI   11,30,16
1E75B1F2E2001F80  387FFFC0  ADDI   3,31,-64
1E75B1F2E2001F84  63CC0000  ORI    12,30,0
1E75B1F2E2001F88  78CAC1C6  RLDICR 10,6,56,7
1E75B1F2E2001F8C  7C0103E6  SETTAG
1E75B1F2E2001F90  7CA50040  CMPL   1,1,5,0
1E75B1F2E2001F94  40860048  BC     4,6,0X48
1E75B1F2E2001F98  41820014  BC     12,2,0X14
1E75B1F2E2001F9C  8CA40001  LBZU   5,0X1(4)
1E75B1F2E2001FA0  2C250000  CMPI   0,1,5,0
1E75B1F2E2001FA4  8C0C0001  LBZU   0,0X1(12)
1E75B1F2E2001FA8  4BFFFFE8  B      0X3FFFFE8

The first CMPI sets CR0.EQ from the input byte. The instructions before CMPL do not change CR0. SETTAG affects the tag state, not the condition registers. CMPL 1,1,5,0 sets CR1.EQ from the comparison of the input and expected bytes.

The branch at 0x1E75B1F2E2001F94 tests CR1.EQ and reaches the failure block when the bytes differ. The next branch tests CR0.EQ and reaches success when the input byte is zero. Equal nonzero bytes continue the loop.

The encoded displacements make the control flow explicit: 

0x1E75B1F2E2001F94 + 0x48 -> 0x1E75B1F2E2001FDC  failure
0x1E75B1F2E2001F98 + 0x14 -> 0x1E75B1F2E2001FAC  success
0x1E75B1F2E2001FA8 - 0x18 -> 0x1E75B1F2E2001F90  next comparison

The saved text supports that mapping: silentsignal is at logical offset 0x69B0 , pwd is ok at 0x69C0 , and wrong at 0x69D0 . The success block selects the text at r30+0x10 ; the failure block selects r30+0x20 .

I replaced only the mismatch branch: 

before  40860048  BC 4,6,0X48
after   60000000  ORI 0,0,0

The variants produced this result:

Saved variant PVV Instruction after resave Output for incorrect input
baseline valid original branch wrong
changed branch, stale PVV stale original branch wrong
changed branch, repaired PVV valid changed instruction pwd is ok

The repaired program printed pwd is ok for both nope and x . A fresh save of the repaired object still contained 60000000 at the instruction site identified from the object structure.

Restore access: command and API controls

IBM’s documented Restore Object List ( QSRRSTO ) API has a different authority model from the Restore Object ( RSTOBJ ) command. IBM has documented its default public authority as *USE since the 2006 Backup and Recovery APIs manual . That permits calling the API; it does not supply the user-space, save-file, library, or target-object authorities required for a restore. Callers without the *SAVSYS save-system special authority must satisfy those documented authority requirements, as USERB1 did within its test library.

For the end-to-end control, I rebuilt CrackMe from the retained source and the same compiler settings. I resolved the patch location from the new SAVF. The rebuilt program contained the same 40860048 mismatch branch at native record 1 offset 0xB4 . I created baseline, branch-edited/stale-PVV, and branch-edited/repaired-PVV variants; all three had valid SAVF checks.

With the repaired SAVF loaded into save file TESTSAVF in the USERB1 library and the target absent, RSTOBJ failed with CPD0032 (not authorized to the command) and created no program. To test the API separately, I used a small, locally written USERB1-owned program that called QSRRSTO directly and restored PVVPASS into the USERB1 library. Both the caller and a small USERB1-owned wrapper that recorded the job context before and after invoking the caller were USRPRF(*USER) and USEADPAUT(*NO) , so they neither adopted their owners’ authority nor used authority adopted higher in the call stack. In the same job, the wrapper used IBM’s Retrieve Job Attributes command ( RTVJOBA ) to report current user USERB1 immediately before and after the API call.

Under this authority context, the repaired variant produced the CrackMe output reported above. Its resave retained 60000000 at native record 1 offset 0xB4 , and its 1,032-byte executable payload matched the repaired input after the final eight-byte saved-space pointer was removed from each native record.

The stale-PVV API control restored with the original branch and printed wrong instead. This was one end-to-end test within USERB1’s authorized object scope: command denial, API restore, execution, and resave.

I then rebuilt MEMDUMP entirely as USERB1, applied the native edits to its saved representation, and repaired PVV and the SAVF checks. Running as USERB1, I called QSYS/QSRRSTO ; it created the MEMDUMP program in the USERB1 library as a USER-state, USER-domain program owned by USERB1, with USRPRF(*USER) and USEADPAUT(*NO) . A fresh save retained both modified instruction sites. The repaired input, the USERB1-restored resave, and the distinct program object used for the memory-read test had byte-for-byte identical 1,496-byte executable payloads.

Signature, state, and domain boundaries

The native code controls above used USER state. I also tested the separate state, domain, and signature boundaries.

Control Result
USER to SYSTEM state, PVV repaired IBM i rejected it as unsigned with CPD37A0 , then CPF3770 (no object restored)
USER to INHERIT state, PVV repaired IBM i rejected it as unsigned with CPD37A0 , then CPF3770 (no object restored)
USER state, USER to SYSTEM domain, PVV repaired IBM i restored it with CPC3703 ; a USER-state call failed with MCH6801 domain violation

The repaired SYSTEM-state fixture passed the offline reconstructed PVV check, but the live restore failed the digital signature requirement: 

offline PVV validation         PASS
live trusted-signature check   FAIL

I also traced the complete 16-bit state field. The relevant LIC branches reduce to this classification before the signature service is called: 

state 0x0001 -> record flag 0
state 0x8000 -> record flag 0
all other 65,534 values -> record flag 1

The flag is an input to the later signature path, not the final restore result by itself. Canonical SYSTEM state is 0x0080 , and INHERIT state is 0x0000 ; both produce flag 1. The activation resolver separately treats 0x0000 as INHERIT, selects SYSTEM only for 0x0080 , and sends 0x0001 , 0x8000 , and other noncanonical values to USER. I found no state value that both takes the flag 0 path and activates as SYSTEM on this route.

The 0x8000 state value is not SYSTEM state. It restored and activated as USER in the live control. The same hexadecimal value appears as the two-byte domain contribution for SYSTEM domain, but that is another field.

Security impact

Under the tested conditions, externally modified USER-state native code bypassed a compiler-generated pointer-validation sequence and performed a memory access that the original compiled code could not. CrackMe independently established execution of modified native bytes; the controlled MEMDUMP runtime test established this consequence. The compiler-generated path used LQ to load the 128-bit pointer and record its tag status, TXER to check that status, and _SETSPPFP (Set Space Pointer from Pointer) before the memory access. At native section offset +0x220C , I replaced the first two instructions with a direct native load and branch: 

; original
2f3708714600220c:  e2dfff9b  LQ         22,0XFF90(31),11
2f37087146002210:  7c0004c8  TXER       0,0,41
; replacement
2f3708714600220c:  eb7fff98  LD         27,0XFF98(31)
2f37087146002210:  48000028  B          0X28
; later target access
2f370871460022b8:  889b0000  LBZ        4,0X0(27)

The source had copied the supplied 64-bit address into this r31 -relative slot; the LD loads it into r27 , and the branch continues at +0x2238 . The later LBZ at +0x22B8 performs the byte read through r27 . With the same supplied address, the unmodified MEMDUMP failed with MCH3601 (pointer not set). The modified code bypassed the generated validation sequence and, when invoked as USERB1, returned the exact expected 32 bytes from a known-address USER-domain buffer belonging to a cooperating QSECOFR job. The target address was supplied by the cooperating QSECOFR job; obtaining such an address independently is a separate prerequisite.

For the supported saved-program format, the derivable HMAC key makes PVV a recomputable consistency check. With an editable SAVF and an authorized restore path, recalculating PVV and the SAVF checks preserved the tested USER-state native changes. Separate controls enforced trusted signatures for the tested SYSTEM and INHERIT variants and blocked USER-state access to SYSTEM-domain storage.

Conclusion

PVV was the missing piece between editing saved native POWER instructions and preserving them through IBM i restore so that the modified code could execute. Reconstructing it turned that obstacle into a repeatable research workflow: CrackMe demonstrated changed native control flow, while MEMDUMP showed its practical consequence in a controlled, known-address USER-domain read. The PVV reconstruction is not by itself a vulnerability or a signature bypass; the pvv-ibmi release accompanying this article lets other researchers reproduce the calculation and use the same workflow, while restore authorization, trusted signatures, and domain enforcement remain separate boundaries.

Safari 27.3 Adds Support for Global Privacy Control

Daring Fireball
pxlnv.com
2026-11-10 09:47:10
Nick Heer, Pixel Envy: There are a whole bunch of features and fixes coming to Safari with Apple’s OS 27.3 update. One that is not in the beta release notes but appears nevertheless is support for Global Privacy Control. This new standard is effectively a replacement for Do Not Track with legal ...
Original Article

Safari 27.3 Adds Support for Global Privacy Control ⇥ developer.apple.com

There are a whole bunch of features and fixes coming to Safari with Apple’s OS 27.3 update. One that is not in the beta release notes but appears nevertheless is support for Global Privacy Control . This new standard is effectively a replacement for Do Not Track with legal muscle that should permit you to indicate your tracking preference one time and then, theoretically, never again see a cookie consent banner.

In practice, it will take time for websites to add support, and it requires users to enable the feature in Safari’s Settings. I do not love the implementation in the first beta, which buries the checkbox in the Advanced tab with the ambiguous label “Use Global Privacy Control”, unlike the company’s proprietary anti-tracking features that live in the Privacy tab. But at least it is present and, in my testing, functional.

The Death Knell of Digital Search

Hacker News
www.newyorker.com
2026-11-10 09:41:36
Comments...
Original Article

Lately, I’ve been having trouble finding stuff in my Gmail inbox. The Search function has become overzealous, jumping to summarize my conversations using artificial intelligence and skipping the actual addresses I’m attempting to search. It’s not just e-mail accounts, though; search is in crisis everywhere. Google Maps guesses where I want to go at a given time of day instead of simply listing places I’ve just searched for. When I try to use Google Search, the A.I.-overview function sometimes occupies my entire browser window, generating its own, not always correct, answers rather than directing me to relevant websites. Full-on A.I. mode skips the old blue links entirely.

Search has gotten so annoying, in fact, that it has become a problem for Google’s very business model. Companies pay Google to splash ads into search results that are relevant to their businesses—advertising stoves, say, to someone searching for kitchen-renovation tips. More than half of Google’s revenue comes from those ads. But, if users aren’t clicking through to external sites, because they’re relying on A.I. to answer their queries, then the ads that Google hosts are suddenly much less valuable. In a recent earnings call, Google’s chief business officer, Philipp Schindler, admitted that the company has been seeing “lower monetization” on A.I. searches. After the call, the stock of Alphabet, Google’s parent company, fell by nearly a quarter, down five hundred billion dollars, the largest single-day drop in its history. Even Google may not be too big to fail, as pessimism mounts about the possibility of Search ever again working the way it used to.

Just as Google has faltered in Search, use of OpenAI’s ChatGPT has surged. OpenAI’s consumer-product lead, Adam Fry, recently told the tech journalist Alex Kantrowitz that ChatGPT is siphoning users away from the older company: over the past year and a half, it has grown to handle one-fifth the volume of “search-like queries” that Google does. This acceleration only makes sense: a growing number of people now rely on A.I. chatbots as their primary windows to the internet, and they’re less likely to click out of those apps to ask the kinds of simple questions that they might once have turned to Google to answer. It doesn’t help that bots have lately grown much better at browsing the internet in real time, using virtual browsers and plug-ins, rather than simply generating answers from preëxisting data. Google has its own suite of A.I. products, Gemini, but they’ve lagged in popularity behind Anthropic’s Claude and ChatGPT. The investment firm Menlo Ventures found that Gemini accounts for only nine per cent of A.I. spending for businesses in 2026, down from twenty-one per cent last year.

Can the internet as we know it survive without a reliable flood of search traffic? Chatbots treat websites as databases of information to draw from, but since they divert traffic from those sites they don’t provide much impetus for creators to keep posting new content. The end state we’re heading toward seems to be an internet both generated and traversed by bots—in which case, it will no longer matter how annoying it is for a mere human being to find information. Some websites are already moving defensively to keep out the trawling bots attempting to digest their content. Reddit, one of the internet’s major remaining repositories of human-generated knowledge and opinions, is moving toward “a primarily logged-in experience,” as its C.E.O., Steve Huffman, recently announced. In a third-quarter letter to shareholders, Huffman noted that Reddit’s search traffic “dropped by more than 1 million referrals on average per week” during October. The letter explained, “Web search is evolving from a gateway to the web to becoming an AI-powered destination itself.” In a recent earnings call, Huffman said that “people still want Reddit” but that “Google is not sending them to Reddit the way they used to.” Requiring users to log in is the equivalent of pulling up the drawbridge to keep away the A.I. models roaming outside. But it also means that the casual human searcher will be less likely to see the full conversations happening on Reddit.

In 2019, before the A.I. boom, the entrepreneur Yancey Strickler presciently outlined a “ dark-forest theory of the internet .” As the web experience got worse, Strickler argued—because of “the ads, the tracking, the trolling, the hype, and other predatory behaviors”—users would retreat to more private, hidden online spaces, or “dark forests,” in search of human interaction. We once used search to find those dark forests and find the humans on the internet who were doing whatever we were interested in. Now those old tricks of Boolean operators and half-remembered keywords don’t work, because we’re meant to trust a robot to do the navigating for us instead. I often feel that the internet isn’t built for us human users anymore.

One prominent tech-commentator account on X has described companies as locked in “a knife fight for the remaining and dwindling volume of human traffic on the internet.” Many seem to have bought into the narrative that the old-school open internet is done for, so they’re scrambling to lock users into their own, A.I.-automated walled gardens. (Not to be left behind, Reddit is introducing an algorithmic For You feed and A.I.-generated short-form videos based on its content.) Google recently inspired a public backlash when it announced that it would make A.I. functions optional, rather than permanently accessible, on its software suite for schools and students, but with a catch: if schools turned off the Gemini A.I. functions, they would lose access to Google Search, too. This policy amounts to a threat: use generative A.I. or use nothing. The largest tech companies are investing so much capital in A.I. infrastructure—chips, data centers, intensively trained models—that they must make the bet pay off, one way or another.

The upshot is that, more often than not, I find myself using A.I. to fight back against aggressive A.I. Instead of using the Gmail app on my phone, I’ve been texting my questions about my own inbox to an A.I. agent called Instinct, which I recently granted access to my account. (It’s a security risk, to be sure, but one I was willing to take to see if the product is any good for techno-normies.) In a matter of seconds, Instinct can dig up an event invitation or a note from someone whose name I can’t quite remember. Instead of Googling potential interview subjects, I have Claude scrape for their contact information. But I would really prefer if Search just worked the way it did in the first place. ♦

Come and Take It

403 Media
www.404media.co
2026-11-10 09:41:26
AI companies crack down on 'reverse engineer anything.'...
Original Article

AI companies are trying to take the only cool thing their tech has ever done, making me vaguely interested for the first time ever in the concept of open weight models, local AI, etc. Time to take out a second mortgage on the house I don't have to finance a graphics card. Anyways, let's get into it:

‘Reverse Engineer Anything’: AI Companies Crack Down on the Coolest Thing People Were Doing With AI

It was a fun few weeks while it lasted. People using both Anthropic’s Claude and OpenAI’s Codex to do AI-powered “reverse-engineering” or decompiling are now hitting guardrails or having their accounts limited while trying to do things like unbrick their internet-of-things devices or remove surveillance ads from their smart TVs.

Several people have reported triggering “safety checks” in Claude Code that prevented them from doing AI-powered reverse engineering; a highly upvoted Reddit post in r/ClaudeCode reads “The Dream is dead. Reverse Engineer Anything (REA) is not likely to work with Claude.” A thread in the Reverse Engineer Anything Discord from last week reads, “Claude is refusing to decompile anything,” with multiple users responding saying they have hit similar walls. And X user log4j, who used OpenAI’s Codex to reverse engineer Samsung TVs, reported having their OpenAI account banned for violating its rules on “cyber abuse.” Other users said they asked Codex to reverse engineer hardware or their own code now say they have either been warned by the company or had their accounts restricted. A project called Decomp.wtf that made it easier to reverse engineer software and games has also shut down in recent days.

As we reported last month, Reverse Engineer-Anything has made it easy for people to use AI tools to hack electronics that they own and replace a manufacturer’s software or operating system with an open source or vibecoded one. People have installed new operating systems on their smart TVs, have turned baby monitors into AI assistants, have unbricked internet-of-things devices that were abandoned by their manufacturers, and have installed new software on very old hardware. At the time, I wasn’t sure how I felt about the trend, but as I’ve seen people take ownership and control back over the devices that manufacturers have purposefully bricked, turned into spyware, or have placed artificial limitations on, I have come to see AI-powered reverse engineering of electronic devices as one of the few LLM uses genuinely worth getting excited about. And so big companies have immediately taken steps to restrict this behavior.

The policy tweaks show that big AI corporations will protect other big corporations when their users find ways to use LLMs to circumvent the artificial constraints that hardware manufacturers put on their devices. AI-powered copyright circumvention is OK with big tech when it’s a massive company scraping the entire internet to build their LLMs, but is not OK when people then use those tools to liberate their internet-of-things devices. It’s not the end of AI-powered reverse engineering, but people suddenly getting locked out of their accounts for asking AI to reverse engineer their gadgets suggests that the future of this practice lies in open weight, local, and uncensored models, making it less accessible to the masses and the people who could probably benefit from it most.

Tarun Gogineni, an OpenAI engineer, tweeted that people are not supposed to have their OpenAI accounts restricted for reverse engineering: “these blocks are mostly accidental and a result of difficult decision boundaries; there is no prohibition against reverse engineering with codex. it’s getting fixed,” he tweeted.

But people who are doing AI-powered reverse-engineering suggest that they are moving away from big companies’ models to alternatives where they aren’t going to have their accounts disabled or have to figure out how to work around AI company guardrails.

“My general experience about reverse-engineering getting blocked has been more or less 100% correlated with the ‘cyber’ category blocks I have received. My take is that the lab[s] are probably under pressure to not have their models take part in some kind of criminal hacking activities and their cyber guardrails are erring on the side of being too strict,” Matt Brown, principal consultant at Brown Fine Security and someone who has been using AI to reverse-engineer devices, told 404 Media. “I am investing in hardware and trying to stay up to speed because the frontier labs guardrails will randomly change without warning on the same model. For my security research and pentesting work I really don’t want to invest tooling and energy into an ecosystem that will eventually lock me out. These guardrails on the frontier side have come at the same time as open weight models from (mostly) China are getting better and better.”

Read the full story here

More from 404

“Do you have the gun”: According to a police incident report obtained by 404 Media , a father in South Carolina asked his six-year-old daughter if she “had the gun” before he left her alone at Target for more than an hour in the middle of the night so “he could maintain his place in line” to buy Pokémon cards.

Around the web

The biggest thing going on in tech right now is Jensen Huang’s apparent affair with an executive at the data center company Megaspeed who is an alleged Chinese spy. This isn’t the type of thing we cover very closely normally, and Sam mentioned it in the newsletter yesterday, but the latest is that the company is now getting sued over this . The AI slop You Can See Everything memes are out in full force. The incel looksmaxxers have weighed in (if you don’t understand this sentence, I won’t corrupt you). So on and so forth. If you’re curious why any of this might matter, The New York Times has a scoop that the U.S. Department of Commerce killed an investigation into a Megaspeed after Nvidia intervened. Cool government we have here. Anyways, moving on.

ICEd out: The Department of Justice said that it no longer has enough attorneys available to respond to every habeas corpus challenge , and will begin letting judges rule on cases with no government opposition. Basically this suggests that ICE has detained so many people illegally that it no longer has enough attorneys to argue in these cases. Alarming, but also means that enough people are challenging their detentions that ICE is beginning to cry uncle. Also, I would normally never suggest you go watch a Bari Weiss x Ross Douthat joint, but parts of the 60 Minutes interview with Trump were SO WILD . Perhaps this guy doesn’t really stand for anything? Hmm.

Help Court Watch: Our friends over at Court Watch are doing a subscriber drive . Court Watch grabs court records off the notoriously expensive PACER document system and makes them available for free and finds extremely interesting and important cases all the time. We partner with them on a bunch of stories so go check/help them out.

JA / NEIN. Image: Dixken.de

Enough: The best Raspberry Pi on the market now costs $385 . I remember when the whole point of a Raspberry Pi was that it cost, like, $20. This is, of course, due to the RAM/memory/everything shortage caused by AI data center buildout. If you know what people are doing with these top-end Raspberry Pis, let me know?

SLOPPED: Actors alarmed to learn that they had been replaced by AI in the Return of the Living Dead sequel they were set to star in.

DOGE’d: The government’s IT systems are really fucked up , argues our friend Karl Bode in a piece aptly called “U.S. government IT systems are completely compromised and will require a total rebuild.”

The surveillance state, now for kids: The Atlantic has a deep dive on what constant surveillance is doing to children . I haven’t had time to read the full thing yet, but have been waiting for a piece like this for a long time.

They Rickrolled a printer: … They Rickrolled a printer .

About the author

Jason is a cofounder of 404 Media. He was previously the editor-in-chief of Motherboard. He loves the Freedom of Information Act and surfing.

Jason Koebler

A faster Easter date function

Lobsters
www.benjoffe.com
2026-11-10 09:36:45
Comments...
Original Article

A very fast Easter "computus" algorithm, accurate over ±10 million years.

10 November 2026

This post is a fun little side quest to kickstart my journey optimising regional calendars.

Background

Computing the date of Easter faster is not going to matter in any real application. Even in places where it might seem to matter, like high frequency trading applications, it is probably better to just use an in-memory lookup table for holiday dates...
However, no "Fast Date" series would be complete without some mention of this classic problem.

The rules for Easter were broadly decided at the First Council of Nicaea, organised by Emperor Constantine in 325 AD, and later modified by Pope Gregory XIII in 1582 (referred to here as "Gregorian Easter") , with the first Easter under the new rules applying in Catholic countries the following year. The Church of England first observed the new date of Easter in 1753, but Eastern / Orthodox churches continue to follow the old rules.
This article is about the new "Gregorian" Easter, because it is much more complex and slow to compute.

The Function

The code below runs really fast.
It's around twice as fast as a standard easter function that you might find in a typical date library, and I suspect it may be the fastest one made so far 🤷 .
Part of that speed is attributable to using only 5 multiplications (whereas typical reference algorithms have 10 or more multiplications) .

The accuracy range of around -11m → +16m years might seem a bit of overkill, but the reason I targeted this range is so that any date library that expresses dates via a signed or unsigned 32‑bit "rata die", is covered by this function. This means that if you decide to not clamp the logic to years after 1582, at least it will return something resembling the correct rules, rather than garbage.

New Gregorian Easter Function
Given: year ∈ [-11,103,600 ... 16,663,835]
Return: month and day 

  1. u32 constexpr SHIFT = 400 * 19 * (25 * 30 * 2 - 39)
  2. u64 constexpr M19 = (1 << 32) / 19 + 1 + (11 << 32)
  3. u32 constexpr M1C = (1 << 32) / 100 + 1
  4. u32 constexpr M25 = (1 << 32) * 8 / 25 + 1
  5. u32 constexpr M30 = (1 << 32) / 30 + 1
  6. u32 constexpr M67 = (1 << 32) * 6 / 7
  7. 
        
    8. 
        
  8. 
         
    u32 y = year + SHIFT           
    
        
    9. 
        
  9. 
         
    u32 c = (u64) y * M1C >> 32    
    
        
    10. 
        
  10. 
         
    u32 a = (u64) c * M25 >> 32    
    
        
    11. 
        
  11. 
         
    u64 b = (u64) y * M19          
    
        
    12. 
        
  12. 
         
    u32 d = (u32) b > 0x90000000   
    
        
    13. 
        
  13. 
         
    u32 e = b >> 32                
    
        
    14. 
        
  14. 
         
    u32 f = c - (c >> 2)           
    
        
    15. 
        
  15. 
         
    u32 g = a - f + e              
    
        
    16. 
        
  16. 
         
    u32 h = (u64) g * M30 >> 32    
    
        
    17. 
        
  17. 
         
    u32 i = (g + (h << 1)) & 31    
    
        
    18. 
        
  18. 
         
    u32 j = 31 - i - (d >= i)      
    
        
    19. 
        
  19. 
         
    u32 k = y + (y >> 2) + j - f   
    
        
    20. 
        
  20. 
         
    u32 m = k * M67 >> 29          
    
        
    21. 
        
  21. 
         
    u32 v = j + m + 115            
    
        
    22. 
        
  22. 
         
    u32 month = v >> 5
    
        
    23. 
        
  23. 
         
    u32 day = (v & 31) + (v >> 7)
    
        
    24. 
       

      

     

    

    

     

      
      
     

     

      

       
        New Gregorian Easter Function
        

        
         Given:
         
          year
         
         ∈ [-11,103,600 ... 16,663,835]
         

         Return:
         
          Days since 22 March
         
         ∈ [0..34]
        
       
      

      

       
    
        
  1. 
         
    u32 constexpr SHIFT = 400 * 19 * (25 * 30 * 2 - 39)
    
        
    2. 
        
  2. 
         
    u64 constexpr M19 = (1 << 32) / 19 + 1 + (11 << 32)
    
        
    3. 
        
  3. 
         
    u32 constexpr M1C = (1 << 32) / 100 + 1
    
        
    4. 
        
  4. 
         
    u32 constexpr M25 = (1 << 32) * 8 / 25 + 1
    
        
    5. 
        
  5. 
         
    u32 constexpr M30 = (1 << 32) / 30 + 1
    
        
    6. 
        
  6. 
         
    u32 constexpr M67 = (1 << 32) * 6 / 7
    
        
    7. 
        
  7. 
         
    
        
    8. 
        
  8. 
         
    u32 y = year + SHIFT           
    
        
    9. 
        
  9. 
         
    u32 c = (u64) y * M1C >> 32    
    
        
    10. 
        
  10. 
         
    u32 a = (u64) c * M25 >> 32    
    
        
    11. 
        
  11. 
         
    u64 b = (u64) y * M19          
    
        
    12. 
        
  12. 
         
    u32 d = (u32) b > 0x90000000   
    
        
    13. 
        
  13. 
         
    u32 e = b >> 32                
    
        
    14. 
        
  14. 
         
    u32 f = c - (c >> 2)           
    
        
    15. 
        
  15. 
         
    u32 g = a - f + e              
    
        
    16. 
        
  16. 
         
    u32 h = (u64) g * M30 >> 32    
    
        
    17. 
        
  17. 
         
    u32 i = (g + (h << 1)) & 31    
    
        
    18. 
        
  18. 
         
    u32 j = 31 - i - (d >= i)      
    
        
    19. 
        
  19. 
         
    u32 k = y + (y >> 2) + j - f   
    
        
    20. 
        
  20. 
         
    u32 m = k * M67 >> 29          
    
        
    21. 
        
  21. 
         
    return j + m - 3
    
        
    22. 
       

      

     

    

   

   

    Note that this function contains more terms than traditional Easter functions, but bear in mind that the compiled assembly will be a lot smaller. So if you don't care about the speed, but want a tiny impact on binary size, that could be a reason to consider this function.
   

   

    The rest of this post will briefly explain the tricks used in this function:
   

   
   

    
     See also
     
      benchmark results
     
     .
    
   

  

  

   
    Trick #1 - Aggressive Constant Folding
   
   
    Deep link
   
  

  

   
    
    
  1. 
     
    u32 constexpr SHIFT = 400 * 19 * (25 * 30 * 2 - 39)
    
    
    2. 
   

  

  

   You'll notice that the very first thing we do is add a strange value
   
    SHIFT
   
   to the input value. This is done for two reasons:
  

  
    
   
  1. 
    to move all dates to the positive domain to avoid complexity associated with signed operations
   
    2. 
   
  2. 
    but also importantly, to allow various constants throughout the algorithm to be factored out.
   
    3. 
  

  

   For example, most Easter algorithms have a term like
   
    (5 + 8 * c) / 25
   
   , where
   
    c
   
   is the century (
   
    year / 100 + 1
   
   ). The term
   
    25
   
   in the calculation of shift is responsible for aligning the century such that the constant
   
    5
   
   can be removed, resulting in
   
    c * 8 / 25
   
   , which is then approximated in the final algorithm with a single mul-shift:
   
    (u64) c * M25 >> 32
   
   .
  

  

   

    

     Other terms in
     
      SHIFT
     
     :
     
      19, 400, 30
     
     are all doing similar things related to the 19-year-cycle, 400-year-cycle, and mod-30 steps.
     

     The term
     
      * 2
     
     is different. Without this term, the range of coverage would be -5,403,600 → +22,363,835; which doesn't quite cover the range we wanted, which for signed 32-bit rata die, is ±5.88m years. Including
     
      * 2
     
     increases the value of shift by exactly 5,700,000, which is how many years it takes for the Easter pattern to repeat, and gets the range we are after.
    

    

     If you like this type of optimisation, but are not a fan of the low-level bit-shifting and so on, then you might prefer to use this function here below. It is a much more readable version of the function, which only has these higher-level optimisations applied.
    

    

     Note that unlike in the main function presented earlier,
     
      MOD 30
     
     needs to be a positive-modulus function (even for positive dates), and that the
     
      nextSunday
     
     helper is anchored to the internal logic of the function, not related to Unix day-counting.
    

   

   

    

     

      
       Readable Easter Function
       

       
        Given:
        
         year
        
        ∈ [-11,103,600 ... 2
        
         31
        
        -1]
        

        Return:
        
         Days since 22 March
        
        ∈ [0..34]
       
      
     

     

      
    
       
  1. 
        
    u32 getEpact(u32 y, u32 c, u32 f) {
    
       
    2. 
       
  2. 
        
      u32 n = y % 19
    
       
    3. 
       
  3. 
        
      u32 i = i32(11 * n - f + c * 8 / 25) MOD 30
    
       
    4. 
       
  4. 
        
      return 31 - i - ((n > 10) >= i)
    
       
    5. 
       
  5. 
        
    }
    
       
    6. 
       
  6. 
        
    
       
    7. 
       
  7. 
        
    u32 nextSunday = (u32 k) => 7 - (k % 7)
    
       
    8. 
       
  8. 
        
    
       
    9. 
       
  9. 
        
    
       
    10. 
       
  10. 
        
    u32 simpleEaster(i32 year) {
    
       
    11. 
       
  11. 
        
      u32 constexpr SHIFT = 400 * 19 * (25 * 30 * 2 - 39)
    
       
    12. 
       
  12. 
        
      u32 y = year + SHIFT
    
       
    13. 
       
  13. 
        
      u32 c = y / 100
    
       
    14. 
       
  14. 
        
      u32 f = c - c / 4
    
       
    15. 
       
  15. 
        
      u32 j = getEpact(y, c, f)
    
       
    16. 
       
  16. 
        
      u32 m = nextSunday(y + y / 4 + j - f)
    
       
    17. 
       
  17. 
        
      return j + m - 3
    
       
    18. 
       
  18. 
        
    }
    
       
    19. 
      

     

    

    

     
      
       Note: a
       
        variant
        
       
       in the C++ repo has some small optimisations not shown here (fast day-of-week and fast mod 30), and a range of [-73,803,600 .. 70,208,581].
      
     
    

   

  

  

   
    Trick #2 - Never computing:
    
     year mod 19
    
    .
   
   
    Deep link
   
  

  

   Computing
   
    
     year
    
    
     %
    
    19
   
   is a staple of Easter algorithms.
   

   It's related to the
   
    Metonic cycle
   
   , where every 19 years there are nearly exactly 235 full moons.
  

  

   It is traditionally used in Easter algorithms in two ways:
  

  
    
   
  1. 
    a term like:
    
     (11
     
      *
     
     (
     
      year
     
     
      %
     
     19) + ... )
     
      %
     
     30
    
    ;
    
     
      –
      
       and:
      
     
    
   
    2. 
   
  2. 
    a term like:
    
     (
     
      year
     
     
      %
     
     19) > 10
    
   
    3. 
  

  

   We are going to compute these same things using a single multiplication.
   

   These steps seem unavoidable at first, but they can be eliminated. We'll begin by expanding the first one:
  

  

   
    (11
    
     *
    
    (
    
     year
    
    
     %
    
    19) + ... )
    
     MOD
    
    30
   
   

   
    (11
    
     *
    
    (
    
     year
    
    -
    
     year
    
    
     /
    
    19
    
     *
    
    19) + ... )
    
     MOD
    
    30
   
   

   
    (11
    
     *
    
    
     year
    
    -
    
     year
    
    
     /
    
    19
    
     *
    
    209 + ... )
    
     MOD
    
    30
   
   

   
    (11
    
     *
    
    
     year
    
    +
    
     year
    
    
     /
    
    19 + ... )
    
     MOD
    
    30
   
  

  

   The last step there might be the least obvious. It works because we can add any multiple of
   
    30
   
   to the multiplier and get the same result (a property of
   
    MOD
   
   ), so add
   
    30 × 7 = 210
   
   , which means we can remove the multiplication by
   
    209
   
   and just invert the sign.
  

  

   This leaves us with only two terms related to
   
    year
   
   which can be computed efficiently in parallel, however using a 64‑bit multiplier, we can actually merge these into one (fixed-point multiplication by
   
    11
    
     1
    
    /
    
     19
    
   
   ):
  

  

   
    
     u64 constexpr
    
    
     M19
    
    = (1 << 32) / 19 + 1 + (11 << 32)
   
   

   
    ((
    
     year
    
    
     *
    
    
     M19
    
    >> 32) + ... )
    
     MOD
    
    30
   
  

  

   
    
     This is the only 64‑bit multiplication in the function, and a 32-bit compiler should have no trouble turning that back into the previous pair of multiplications.
    
   
  

  

   The algebra above relies on
   
    
     MOD
    
    30
   
   , which is different to
   
    
     %
    
    30
   
   in C for negative numbers.
   

   The value being computed does not go negative over our range, so the substitutions remain valid.
  

  

   Now on to the other term:
   
    (
    
     year
    
    
     %
    
    19) > 10
   
   . It is a well known trick to use the low bits from the mul-shift of division by
   
    19
   
   as a comparison cutoff, and the version used in my function is
   
    
     u32
    
    (
    
     b
    
    ) > 0x90000000
   
   . The extra term in our multiplier (
   
    11 << 32
   
   ) has no effect in the lower 32‑bits, so this still works. Cassio Neri has written about things like this, if you want to read more you can start with this
   
    Overload Edition 154
    
   
   .
  

  

   So, this is just one multiplication plus the
   
    MOD 30
   
   , which is usually an additional two multiplications, but we'll eliminate those later in
   
    
     Trick #4
    
   
   .
  

  

   
    Trick #3 - Computing "X − (Y % 7)" without negation.
   
   
    Deep link
   
  

  

   There's always a
   
    % 7
   
   term in these Easter functions, which is then
   
    subtracted
   
   from a final result. This is because Easter is on the “
   
    first Sunday after [...]
   
   ”.
  

  

   Clearly we are going to use the fast-mod-7 trick from the
   
    weekday article
   
   . If you haven't read that article, you should. You won't understand this section otherwise, and frankly, it's a better article than this one.
  

  

   
    

     

      
       Fast computation of:
       
        y = 7 - (x % 7)
       
       

       
        Valid range:
        
         1 ≤ x ≤ 178,956,972
        
       
      
     

     

      
    
       
  1. 
        
    u32 const M67 = (1 << 32) * 6 / 7
    
       
    2. 
       
  2. 
        
    u32 y = x * M67 >> 29
    
       
    3. 
      

     

    

    

     The same mod-7 trick as before, but notice that the mapping is reversed? (The numbers track anti-clockwise)
    

   
  

  

   So why not just subtract the result of
   
    % 7
   
   like everybody else? Well, that would make the final line be:
   
    j - m + C
   
   (for some constant
   
    C
   
   ). This does not fit the pattern of a single-operation
   
    LEA
   
   instruction on x86.
  

  

   Instead, we adapt the fast-mod-7 code to use a fixed-point multiplier of
   
    6 / 7
   
   (rather than
   
    1 / 7
   
   ) before the right-shift-29, which means this line actually counts mod-7 backwards for us! This means the final line can be
   
    j + m + C
   
   , which fits
   
    LEA
   
   and saves... one cycle  😀
   
    
     (depending on the compiler and CPU...)
    
    .
   
  

  

   
    Trick #4 - Computing MOD 30 faster with the mod-pad technique
   
   
    Deep link
   
  

  

   
    
    
  1. 
     
    u32 constexpr M30 = (1 << 32) / 30 + 1
    
    
    2. 
    
  2. 
     
    u32 h = (u64) g * M30 >> 32
    
    
    3. 
    
  3. 
     
    u32 i = (g + (h << 1)) & 31
    
    
    4. 
   

  

  

   This one is pretty obvious if you've been following this blog series.
   

   
    MOD 30
   
   can be calculated faster by using our favourite identity:
  

  

   This was introduced and proven in the
   
    weekday
   
   article, and utilised more notably in the
   
    time-of-day
   
   article.
   

   Here setting
   
    D = 30, c = 2
   
   gives us the useful version where we can apply
   
    MOD 32
   
   
    (same as
    
     & 31
    
    )
   
   .
  

  

   
    Trick #5 - The fancy day & month
   
   
    Deep link
   
  

  

   
    
    
  1. 
     
    u32 v = j + m + 115
    
    
    2. 
    
  2. 
     
    u32 month = v >> 5
    
    
    3. 
    
  3. 
     
    u32 day = (v & 31) + (v >> 7)
    
    
    4. 
   

  

  

   This final bit, I'm not sure if it's been done before exactly like this.
  

  

   Easter can only ever be in March or April (month 3 or 4), and luckily March is 31 days long, which means we can use
   
    % 32
   
   to truncate dates there. A straightforward modulus would cause March 32 to overflow to April
   
    0
   
   , a non-existent date, so we add the term
   
    v >> 7
   
   which increments the date when it overflows
   
    (a lucky coincidence relying on April, month
    
     4
    
    , being a power-of-2)
   
   .
  

  

   I have seen similar things done before using
   
    % 31
   
   , but I have not seen this with the clean bit-mask approach.
  

  

   So, that's it. A bunch of fussing about to make a simple streamlined function that is next to impossible to read... but fast.
  

  

  

   This article was prompted by Twitter/X user
   
    Dirk Loss
    
   
   replying to one of my posts with a link to a ChatGPT thread, where he used AI to compute Easter faster.
   
    See ChatGPT thread.
    
   
  

  

   
    Screenshot of X post by Dirk Loss (@dloss): "Could these kinds of optimizations be done for calculating Easter, too? I posed this to ChatGPT:"
   
  

  

   The AI actually did a pretty good job.  It used learnings from my prior blog posts to apply various optimisations, but also came up with new twists on these ideas. It produced a function that is
   
    really fast
   
   , and that is accurate over the range 1498–14,544. The range is a fairly reasonable choice given that the modern rules for Easter took effect after 1582, and nobody really needs Easter further into the future.
  

  

   In a serious case of
   
    "Not Invented Here"
   
   syndrome
   
    (on behalf of human kind)
   
   , I had to see if I could beat the AI. I clearly did, otherwise there wouldn't be this blog post. The wider-range algorithm presented in this article has around 5-15% higher throughput across tested platforms, and similar latency (despite the wider range).
  

  

   My algorithm was adapted from the one presented in Calendrical Calculations (Reingold and Dershowitz).
   

   I did not apply any learnings from the ChatGPT one, though we settled on several similar steps.
  

  

   I suspect this function could be optimised more, as it still has the same overarching structure of existing algorithms going back a
   
    very
   
   long time.
   

   I tried for a little while to find a shortcut solution using the Python "Z3 Theorem Prover", which found an alternative which is a further 15-20% faster than my main one, however it's only accurate over a micro range [1894 .. 2199].
   
    It is available in the testcase repo
    
   
   . If you can find a function of similar or faster speed with a wider range, feel free to let me know and I will update the repo and this page!
  

  

   Although I beat the AI in this case, it’s a pretty mild victory as it was just a basic model with a moderate amount of compute. It’s sad to know that if frontier models were pointed at the problems I’ve been tackling in this blog series, they would probably unearth every last jewel of optimisation left in the blink of an eye. I hope that I have time to explore this space more before it becomes barren.
  

  

   If you enjoyed this post, you should
   
    follow me on X
    
   
   to get notified when I publish more date and algorithm related articles.
  

  
  

   Benchmark Results
   
    Deep link
   
  

  

   Exhaustive tests of the ranges asserted in this article can be verified via the testcase code:
   
    https://github.com/benjoffe/fast-world-calendars
    
   
   .
  

  

   The same repository is used for benchmarking, where a large set of random years are loaded into memory and tested.
  

  

   All results were obtained by running the benchmark with
   
    -repeat=10
   
   and recording the
   
    median
   
   results.
   

   The
   
    -batch
   
   flag runs each computation 3 times before loading the next entry from memory. This ensures that the processor is not bottlenecked by memory access.
   

   Latency results use the same command but replace the batch flag with
   
    -latency
   
   . This mode feeds the result of each computation into the next, so there is no parallelisation.
  

  

   
git clone https://github.com/benjoffe/fast-world-calendars.git
cd fast-world-calendars
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j
./build/bin/easter_test
./build/bin/easter_bench -batch
./build/bin/easter_bench -latency

  

  

   The number in a small font size represents the number of nanoseconds per year computation.
   

   The larger number is the ratio of these results compared to the
   
    New
   
   function as a baseline.
  

  

   
    Note:
   
   the benchmarks compute
   
    "Days since 22 March"
   
   (not day and month), as some of the reference algorithms only return this value.
   

   If my optimisation of the day/month step is novel, then the speedup would be larger than presented here.
  

  

   

    
    
   

   

    
     

      
       Algorithm:
      
      
       Anonymous
       

       (Unsigned)
      		
      
       Calendrical
       

       Calculations
      		
      
       Ian Taylor
       

       (16‑Bit)
      		
      
       Dirk Loss
       

       (ChatGPT)
      		
      
       New
      
      
       New
       

       (Z3/Micro)
      		
     

     

      
       Range (years)
      
      
       0-2
       
        31
       
       -1
      
      
       0-2
       
        31
       
       -1
      
      
       0-2
       
        15
       
       -1
      
      
       1498‑14544
      
      
       > ±10m
      
      
       1894‑2199
      
     

    
    
     

      
       MacBook Pro 2024 (MacOS 15.6.1)
       

       Apple M4 Pro
       

       Compiler: Apple clang 17.0.0
      		
      
       
        1.92x
       
       

       
        (2.35951)
       
      		
      
       
        2.99x
       
       

       
        (3.67602)
       
      		
      
       
        1.81x
       
       

       
        (2.22827)
       
      		
      
       
        1.07x
       
       

       
        (1.31419)
       
      		
      
       
        1.00x
       
       

       
        (1.23101)
       
      		
      
       
        0.85x
       
       

       
        (1.05075)
       
      		
     

     

      
       AMD Ryzen 9 9950X3D
       

       Ubuntu 24.04.3 LTS
       

       Compiler:
       
        Clang
       
       18.1.3 (x86_64)
      		
      
       
        2.19x
       
       

       
        (3.38572)
       
      		
      
       
        2.72x
       
       

       
        (4.21668)
       
      		
      
       
        2.01x
       
       

       
        (3.11688)
       
      		
      
       
        1.14x
       
       

       
        (1.76154)
       
      		
      
       
        1.00x
       
       

       
        (1.54947)
       
      		
      
       
        0.79x
       
       

       
        (1.21701)
       
      		
     

     

      
       AMD Ryzen 9 9950X3D
       

       Ubuntu 24.04.3 LTS
       

       Compiler:
       
        GCC
       
       14.2.0 (x86_64)
      		
      
       
        2.31x
       
       

       
        (3.30348)
       
      		
      
       
        3.48x
       
       

       
        (4.96507)
       
      		
      
       
        2.07x
       
       

       
        (2.94695)
       
      		
      
       
        1.16x
       
       

       
        (1.66054)
       
      		
      
       
        1.00x
       
       

       
        (1.42701)
       
      		
      
       
        0.85x
       
       

       
        (1.21541)
       
      		
     

    
   

  

  

   
    Revision history:
   
  

  
    
   
  • 
    
     10 November 2026 - First release
    
   
    • 
  

 




        

      

    
    

        

          
‘A Scandal at the Center of the Economy’

        

        

          Daring Fireball
        

	

	  www.theatlantic.com
	

        

          2026-11-10 09:36:18
        

        

          
          

            Charlie Warzel, writing for The Atlantic (gift link):


  It is curious, then, that, as news came out that the Nvidia CEO,
Jensen Huang, had had a romantic relationship with a Chinese
businesswoman who was also an asset of Beijing’s Ministry of State
Security, notable factions of Silicon Valley and ...
          

        

        

          
Original Article

          

 

  

   Our site’s security protections triggered a block. If you
                    think this was in error, email us at
   
    
     [email protected]
    
   
   . Please include how you got to this webpage and the
                    Cloudflare Ray ID located at the bottom of the page.
  

  

   If you would like to inquire about permission to access our
                    content, email us at
   
    
     [email protected]
    
   
   .
  

  

   Cloudflare Ray ID:
   
    a585edfd79b157a2
   
  

  

   
    Back to
    
     The Atlantic
    
   
  

 




        

      

    
    

        

          
U.S. Commerce Dept. Inquiry Into Megaspeed Was Halted After Nvidia Name-Dropped Trump Appointee

        

        

          Daring Fireball
        

	

	  www.nytimes.com
	

        

          2026-11-10 09:35:38
        

        

          
          

            Ana Swanson and Devlin Barrett, reporting yesterday for The New York Times (gift link):


  Investigators at the Commerce Department were deep into a
monthslong investigation of a Singaporean company that they
suspected of smuggling Nvidia’s artificial intelligence chips
into China when their work c...
          

        

        

          
Original Article

          

 

  Please enable JS and disable any ad blocker
 




        

      

    
    

        

          
New York's Most Eligible (?) Former Mayor Is Finally Off the Market

        

        

          hellgate
        

	

	  hellgatenyc.com
	

        

          2026-11-10 09:31:00
        

        

          
          

            A match made at the Citizens Budget Commission, and more news for your Tuesday morning....
          

        

        

          
Original Article

          

 

  

   He was a billionaire politician who is maybe not
   
    so
   
   politically relevant; she was his girlfriend of 26 years, a financial executive, whatever that means. Can we make it
   
    
     any more obvious
    
   
   ?
  

  

   That's right: Former New York City Mayor Michael Bloomberg and his longtime partner Diana Taylor
   
    
     finally tied the knot
    
   
   on Monday after more than a quarter century together. And what a quarter century it's been!
  

  

   "Twenty-six years after a chance seating assignment, Mike Bloomberg and Diana Taylor have married," a spokesperson for Bloomberg
   
    
     posted
    
   
   on the ex-mayor's X account. "The longtime couple exchanged vows today in a small, private ceremony at their home on the Upper East Side, joined by family, including his daughters, Emma and Georgina. The two first crossed paths when they sat next to each other at a Citizens Budget Commission meeting while he was first running for Mayor."
  

  

   Extremely romantic origin story aside (we always thought it was strange that the Citizens Budget Commission only meets by candlelight at that cute hole-in-the-wall Italian spot down the block), Bloomberg and Taylor have been through a lot together over the last two and a half decades.
  

 

 

  

   Give us your email to read the full story
  

  

   Sign up now for our free newsletters.
  

  

   
    Sign up
   
  

 




        

      

    
    

        

          
'Reverse Engineer Anything': AI Companies Crack Down on the Coolest Thing People Were Doing With AI

        

        

          403 Media
        

	

	  www.404media.co
	

        

          2026-11-10 09:21:37
        

        

          
            

          
          

            The future of hacking your devices is in local and open-weight AI....
          

        

        

          
Original Article

          

 

  

   

    

     It was a fun few weeks while it lasted. People using both Anthropic’s Claude and OpenAI’s Codex to do AI-powered “reverse-engineering” or decompiling are now hitting guardrails or having their accounts limited while trying to do things like unbrick their internet-of-things devices or remove surveillance ads from their smart TVs.
    

    

     Several people have reported triggering “safety checks” in Claude Code that prevented them from doing AI-powered reverse engineering; a
     
      
       highly upvoted Reddit post in r/ClaudeCode
      
     
     reads “The Dream is dead. Reverse Engineer Anything (REA) is not likely to work with Claude.” A thread in the Reverse Engineer Anything Discord from last week reads, “Claude is refusing to decompile anything,” with multiple users responding saying they have hit similar walls. And X  user log4j, who used OpenAI’s Codex to reverse engineer Samsung TVs,
     
      
       reported having their OpenAI
      
     
     account
     
      
       banned
      
     
     for
     
      
       violating
      
     
     its rules on “cyber abuse.” Other users said they asked Codex to reverse engineer hardware or their own code now say they have either been warned by the company or had their accounts
     
      
       restricted
      
     
     . A project
     
      
       called Decomp.wtf
      
     
     that made it easier to reverse engineer software and games has also shut down in recent days.
    

    

     As we reported last month,
     
      
       Reverse Engineer-Anything
      
     
     has made it easy for people to use AI tools to hack electronics that they own and replace a manufacturer’s software or operating system with an open source or vibecoded one. People have installed new operating systems on their smart TVs, have turned baby monitors into AI assistants, have unbricked internet-of-things devices that were abandoned by their manufacturers, and have installed new software on very old hardware. At the time, I wasn’t sure how I felt about the trend, but as I’ve seen people take ownership and control back over the devices that manufacturers have purposefully bricked, turned into spyware, or have placed artificial limitations on, I have come to see AI-powered reverse engineering of electronic devices as one of the few LLM uses genuinely worth getting excited about. And so big companies have immediately taken steps to restrict this behavior.
    

    

     The policy tweaks show that big AI corporations will protect other big corporations when their users find ways to use LLMs to circumvent the artificial constraints that hardware manufacturers put on their devices. AI-powered copyright circumvention is OK with big tech when it’s a massive company scraping the entire internet to build their LLMs, but is not OK when people then use those tools to liberate their internet-of-things devices. It’s not the end of AI-powered reverse engineering, but people suddenly getting locked out of their accounts for asking AI to reverse engineer their gadgets suggests that the future of this practice lies in open weight, local, and uncensored models, making it less accessible to the masses and the people who could probably benefit from it most.
    

    

     Tarun Gogineni, an OpenAI engineer,
     
      
       tweeted that people
      
     
     are not supposed to have their OpenAI accounts restricted for reverse engineering: “these blocks are mostly accidental and a result of difficult decision boundaries; there is no prohibition against reverse engineering with codex. it’s getting fixed,” he tweeted.
    

    

     But people who are doing AI-powered reverse-engineering suggest that they are moving away from big companies’ models to alternatives where they aren’t going to have their accounts disabled or have to figure out how to work around AI company guardrails.
    

    

     “My general experience about reverse-engineering getting blocked has been more or less 100% correlated with the ‘cyber’ category blocks I have received. My take is that the lab[s] are probably under pressure to not have their models take part in some kind of criminal hacking activities and their cyber guardrails are erring on the side of being too strict,” Matt Brown, principal consultant at Brown Fine Security and someone who has been using AI to reverse-engineer devices, told 404 Media. “I am investing in hardware and trying to stay up to speed because the frontier labs guardrails will randomly change without warning on the same model. For my security research and pentesting work I really don’t want to invest tooling and energy into an ecosystem that will eventually lock me out. These guardrails on the frontier side have come at the same time as open weight models from (mostly) China are getting better and better.”
    

    

     
    

    

     
      
       Brown posted a YouTube video last week
      
     
     explaining how he found hidden Bluetooth commands in an internet-of-things gas monitor attached to his propane tank with the open weight model GLM 5.3. He has explained in
     
      
       various posts
      
     
     that the guardrails big companies are putting on reverse engineering are why local AI and
     
      
       open weight models
      
     
     are important.
    

    

     AI-powered reverse-engineering isn’t going anywhere, but it does look like it’s going to become much harder to use the most popular frontier models from OpenAI and Anthropic for it. It’s unclear how much longer it will be possible for you to open an OpenAI Codex window, ask it to find a smart TV hooked up to your network, and tell it to install a new operating system on it. Moving forward, it looks like this type of work will be best done with open source, open weight, uncensored, and local models. That’s a bummer, because one of the things that was so exciting about the Reverse Engineer-Anything trend was how easily accessible it had become.
    

    

     Last month, researchers and law professors at Cornell Tech, Columbia University, and New York University
     
      
       published a paper
      
     
     about how cheap, AI-assisted reverse-engineering is challenging big manufacturers’ dominance over the devices their make, and is challenging existing intellectual property law.
    

    

     “AI systems can identify hardware components, extract firmware, decompile object code, and clone entire apps. The resulting struggle between technology vendors and reverse engineers will challenge a wide range of laws, including trade secret, copyright, anti-circumvention, computer misuse, and contract,” they write. “The law of reverse engineering was built for a world where opening a device took time, tools, and rare expertise. That friction is vanishing as agents whittle endless, precise picks for the many little locks that fill our digital lives.”
    

    

     
    

    

     In recent days, people have started modifying older digital cameras with new, vibe-coded operating systems. In a video about hacking old cameras, the
     
      
       YouTuber Breno Loves Cameras explains
      
     
     why it’s such a big deal and why camera companies don’t like it; that same logic can be applied to any device manufacturer.
    

    

     “Camera companies have this practice of keeping features to release on newer cameras, and having distinctions [in features] in camera lines,” the YouTuber Breno said in one video. “This is breaking that from those big companies, which are going to lose a lot of money if this becomes a big thing.”
    

    

     Through that lens, it’s easy to see why big companies are protecting other big companies. People finally found a thing to do with AI tools that gives consumers a bit more control over the devices they bought; it must be immediately stamped out.
    

    

     “This vibe-code hacking is only called ‘reverse’ when somebody who lacks a trillion dollars is doing it,” the science fiction author Bruce Sterling tweeted. “When you ‘reverse engineer’ the entire Internet Common Crawl, you just built a nice AI model.”
    

    

     

      

       About the author
      

      

       Jason is a cofounder of 404 Media. He was previously the editor-in-chief of Motherboard. He loves the Freedom of Information Act and surfing.
      

     

     

      Jason Koebler
     

    

   

  

 




        

      

    
    

        

          
The U.S. Is Driving Away Young Scientists

        

        

          Hacker News
        

	

	  www.nytimes.com
	

        

          2026-11-10 09:12:59
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  Please enable JS and disable any ad blocker
 




        

      

    
    

        

          
Nest Thermostat in 2026

        

        

          Lobsters
        

	

	  artificially-awesome.com
	

        

          2026-11-10 09:10:39
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   It’s been a long time coming. As someone who’s been first experimenting, then using, and now relying on Home Assistant to automate some portions of my home, I’ve long looked at a few key projects as being just out of reach. This past week I tackled one of those out of reach projects by installing a smart thermostat. Let me quickly catch you up on why I considered this out of reach, and then I will walk through how I choose a thermostat, the hurdles and quirks of installation, and then show the end result.
  

  

   Background
  

  

   The missing C Wire
   A couple years ago we moved from a home built in 1970 to a relatively much more modern home built in 2001. With this came a number of benefits, such as Cat5 Ethernet drops in several rooms, which have enabled me to grow and expand my home network and smart home goals.
  

  

   One such nicety I was truly expecting was a C Wire behind the newer home’s thermostat, unfortunately my hopes were dashed when I took a peak behind the old thermostat on the wall. It was one of those basic 5-day/2-day digital thermostats that were very common in the 90’s/00’s, and was loaded with two AA batteries and no C wire. No C wire meant if I wanted to install a true “smart thermostat” I would be constantly tied to either batteries, a proprietary “C wire adapter” that some companies offer but are not universal, or replacing the thermostat wire in the wall. Truly, what I wanted was to replace the wire in the wall - having a C wire meant I could use nearly any smart thermostat on the market. The smart thermostats that connect with WiFi usually require a C wire as they are generally too power hungry to run on batteries.
  

  

   So I walked away. For two years.
  

  

   I thought, maybe I’ll hire someone to run a new wire for me, but that expense seemed frivolous compared to the various home improvement projects already in line waiting for funding. There it sat, on the back burner for about two years. In that time I’ve continued to expand my smart home, adding a Lay-z-spa WiFi module to the inflatable hot tub, some water leak detectors, a siren, and more. But integrating the homes HVAC climate control remained out of reach.
  

  

   Then, a news story about consumer rights caught my attention. It lead me over to a FULU webpage, which I browsed around for a little while before finding a link to the Nest Thermostat bounty:
   
    Nest Learning Thermostat Gen 1 & 2 [Awarded]
   
  

  

   I had heard of NoLongerEvil when the news originally broke earlier this year. But this reminded me of the project so I jumped into the NLE documentation pages
   
    Introduction - No Longer Evil
   
   and read through the installation steps. Didn’t seem to hard, especially for a 2nd Gen Nest, and there was good support with Home Assistant. Maybe a day or so later I came across a post from someone using a zigbee thermostat in Home Assistant. The C-Wire upgrade continues to roll around in my mind as something worth trying. I order a 50ft 6-wire thermostat cable on Amazon and start pre-planning how I can make the upgrade happen.
  

  

   The missing C Wire
  

  

   So I head down to the basement and locate the existing thermostat cable running from the furnace. I trace it along until it diverts up through a hole in the ceiling. I consider my positioning in the house and believe that this is pretty much directly below where the thermostat is mounted in the hallway on the level above me. I look for how the wire is secured - with many zip ties onto various pipes. Some water lines some gas lines. That is fine but I am concerned with how the wire might have been secured inside the wall behind the thermostat. A single staple could not only ruin my plan for an “easy” upgrade but might mean cutting large holes in walls where I really don’t want to.
  

  

   Old wire
  

  

   Based on the accessibility it didn’t look feasible to fish a new wire to the thermostat while keeping the existing wire in place. Doing so would require adding at least another hole in the basement ceiling, and likely another hole in the wall above, things I would like to avoid. That left me with essentially two options. Either attach the new wire to the old one behind the thermostat and pull down from the basement, or cut the wire in the basement, attach the new wire, and pull up. Either way was essentially the same - once the old wire is pulled out of sight on whichever side, that would be a point of no return.
  

  

   Old wire
  

  

   I decided to attach the new wire in the hallway, behind the thermostat. I disconnected the wires and removed the old thermostat, then used a copious amount of electrical tape to join the new wire with the old one. I returned to the basement and started pulling the old wire down. At first there was essentially no give. I thought I was toast - the installer “must” have put a staple into a stud to secure the old wire behind the wall. I suppose this is probably a builders best practice but sometimes as a homeowner you just need a wire to be able to pull through, ya know?
  

  

   Anyway, I went back upstairs, and pushed and pulled the wire a few inches over and over, trying to free up the drywall enough to hopefully past the thicker taped portion through the drywall. In the end I got my drill and made the existing hole slightly larger thinking this might be the hold up.
  

  

   Back downstairs and on my final hope, I gave the old cable a strong tug and low and behold it started to slide out! I cannot express how much of a relief this was as I was able to get a couple of solid feet to pull through so I figured at this point there must not be anything securing the cable in the wall. All I need to do is get the new cable the few feet from the thermostat location through the floor / basement ceiling hole. Once that is passed it would be straightforward to finish routing the cable by hand.
  

  

   OK, so I head back upstairs and find the new cable has wound up a bit so I straighten it out. Then I think about how I need to avoid pulling the whole new cable into the wall, so I tie the open end to a door handle in the hall. This way i cannot accidentally pull too far.
  

  

   Protect the pull-through at all costs
  

  

   One or two more solid pulls and I see the electrical tape pulling through the ceiling! Yay, I am essentially home free.
  

  

   Taped section pulls through
  

  

   I end up having to go up/down the stairs several more times as the new cable keeps binding up, but each time I can clear the bind and then pull a more through. With a couple feet left upstairs (still tied to the door handle) I stop pulling and prepare to run the wire over to the furnace. The old wire I mentioned was zip tied to pipes for most of it’s routing, but I discovered a long portion of the run was a hot water pipe. This seems like a non-optimal solution considering copper wire is a great transmitter of heat. So instead I pop a couple reusable cable staples into a beam and then run most of the way by following some electrical wires. Near the furnace I go ahead and use cable ties onto nearby conduit for the final part of the run.
  

  

   Taped section pulls through
  

  

   So, we’re at the furnace, now what? Per my researching basically all modern HVAC systems will have a screw terminal for a C Wire. I guess installers just save a couple bucks by running a 4-wire cable instead of a 5-wire cable? I don’t understand this at all and it makes me super annoyed. Anyway, I actually bought a 6-wire cable because it was essentially the same price as a 5-wire, I think literally about a $5 difference. So I have an extra wire just in case some future HVAC enhancement needs another wire. Even in homes not using smart thermostats by default or not needing a C Wire should just have the spare wire there. Leave it un-stripped and taped up or secured with a wire nut, but just don’t run 4-wire cables. Hopefully at some point after 2001 it became a new building code. Rant over.
  

  

   Anyway turn off the power and then pop open the furnace panels and find the wiring area with the old 4-wire cable. I take pictures (always take pictures of before & after!). The wiring is very simple, just using screw terminals. I remove the old wires and connect new ones including the C wire. I actually used the wrong color at first but then found that the default for a C wire is blue so I swapped it. With everything buttoned up I head upstairs and connect the old thermostat. I also enable power to the furnace again. Now I can run through the functions - everything works! (fan on, heat, cool). I’m ready to go smart. Since I hadn’t actually received the new thermostat yet, I go ahead and install the old one back on the wall.
   Rewiring the furnace
  

  

   Picking the upgrade
  

  

   When we left off on the smart thermostat I mentioned a couple of options I was weighing. Either a Nest or one of the Zigbee models (such as the Zen Zigbee Thermostat). I had also considered “rolling my own” from a zigbee controlled relay board as well.
  

  

   In the end I took what feels like the safest option - the Nest 2nd Gen thermostat. Why a Nest with other options exist?
  

  
    
   
  • 
    Solid hardware - people absolutely raved on them when they came out (before Google went and killed all of their smart functions).
   
    • 
   
  • 
    Family friendly - Comparing the user experience of the Nest to the Zen, I feel that the Nest is slightly more user friendly - just rotate the outer ring to change the set temp. The Zen is pretty close though and I don’t think would have been an issue.
   
    • 
   
  • 
    Keeps working if Home Assistant, WLAN, or internet go down (I.e., you can still walk up to it and set the mode or temp manually and it will control HVAC fully offline). I’m not sure if all Zigbee models can do this - likely some can but it was definitely something where I wanted to make sure manual control would always be available even if technology is down.
   
    • 
   
  • 
    Price - absolute steal pricing for used. This makes sense given that the hardware was abandoned by the OEM. Most people don’t want something they have to hack/flash/self-host/etc. This makes picking up a used Nest quite easy. If you decide to go this route be sure to purchase a compatible model (currently only 1st and 2nd Gen is supported with 3rd Gen hopefully in the future) and WITH the required back plate. The Nest is essentially two pieces and you must have both - the back plate connects to your thermostat wires and then the display snaps into that. Without both you will only have a paper weight and weirdly the auction listings I saw for only a back plate were quite a bit more expensive than listings that had both pieces included.
   
    • 
   
  • 
    If you’re in the UK I think there was a 3rd piece you need - some kind of control box for your HVAC - please do your research!
   
    • 
  

  

   Honestly if I had woken up on my other side that morning I might have bought the Zen. I already run most of my smart home on Zigbee, the 2nd hand pricing I saw was very close to that of the Nest 2nd gen, the interface seems simple, etc. It was a close race.
  

  

   Hacking the Nest
  

  

   Before recieving the Nest I went ahead and added the NoLongerEvil app to Home Assistant (HAOS), so that was ready to go.
  

  

   After waiting a few days for the delivery I was ready to swap out the thermostat, but wait, we first have to free it from the evil corporate clutches. In truth I could have plugged it straight in and used it but with Google terminating them it would have been even dumber than my old thermostat - allowing set point and mode, no schedule programming supported - obviously that wouldn’t fly.
  

  

   So I pulled up the NoLongerEvil documentation again and got started. In the end the process was mostly easy with a couple of gotchas. First, be aware that flashing from a Windows PC is not supported. Only Mac and Linux will work. Luckily I already run Bazzite on most PCs so I didn’t have to worry about this one. If I’d only had a Windows PC then flashing a bootable Linux desktop to a USB flashdrive would have only added a few minutes to the process.
  

  

   I opened the AppImage which reported everything was ready to start, I connected the Nest to a MicroUSB (too old for USB-C port) and it booted up.
  

  

   From there things were a little bit “fiddly”. I did have to run the extra terminal command for expanded USB access which was listed as an optional step in the guide. Conversely I didn’t need to install any extra packages as apparently Bazzite had everything needed by default.
  

  

   Upon the first couple of attempts the installer timed out waiting for the Nest to connect. This was mostly because the Nest takes quite a while to boot and the installer times out slightly too soon (I think). On the 3rd try I got the timing right and the installer found the Nest and flashed it.
  

  

   After flash was also a bit “fiddly”. So the Nest booted up from the “NLE” boot screen, confirming the software had loaded successfully. From there the installer goes right into trying to connect to the Nest over the network. However, you have to get the Nest connected to your WiFi network (obviously, but not mentioned anywhere in the setup document). Secondly, after booting up the Nest apparently has a timeout of something like 2-3 minutes where it will function normally but after the timeout it will go to an error screen saying “please connect the back plate” and it simply won’t let you do anything once that comes up. So you might be in the middle of typing in your “a little too complex” WiFi password when the error pops up and there is no way to exit the error except connecting the back plate. So I did that and then went back and re-started entering the WiFi password when a second error popped up of “no wires detected” (or similar) - again no way to exit or go back. Sigh - this was pretty annoying to be honest.
  

  

   Fine - I shut off furnace power, remove the old thermostat and then wire in the new back plate, and then click in the Nest. Now, standing in the hall rather than sitting at my desk I start entering the WiFi for the third time. And once again I am a few character in when “Power not detected on Rh wire” OMG CAN YOU JUST LET ME ENTER THE DARN PASSWORD.
  

  

   Back downstairs, turn on furnace power, back upstairs, the Nest walks through a setup process, shows me which wires are connected, everything looks good. Finally, after probably 20 minutes of being more interrupted, the Nest let’s me finish entering the WiFi credentials.
   Nest back plate
  

  

   Back at my computer - I remember that I probably need to add a VLAN rule to allow Nest specific traffic to reach Home Assistant. I try to keep all IoT devices on a separate WiFi network that by default cannot access the internet or other devices on the LAN. I add the firewall rule and then continue with the installer - it finds the Nest quickly and, applies the LAN address and correct port for Home Assistant / NLE, and we are ready to go.
  

  

   Programming
  

  

   And wow, it’s really really good. First of all, I’ve always been annoyed that “programmable thermostats” are limited to about 4 settings per weekday and per weekend. I figure if you can do 4 why not 6? Why not 8? In our old home we replaced the aging furnace and opted for a “smart touchscreen” thermostat and it was literally the worst. It was a terrible resistive LCD that barely responded to taps, the interface was needlessly complex, burying settings many pages deep, it didn’t allow to setup a fan cycle, and was still limited to 4 temp settings in the schedule. Awful, just awful.
  

  

   Why is the Nest good? First of all, I can’t tell you how much easier it is to program the schedule from a PC browser than trying to stand in the hall and use buttons on the old one. Click the time bubble and enter the temp. Drag the bubble earlier or later. Add more bubbles OMG IT ALLOWS MORE THAN 4 PER DAY ITS A MIRACLE.
  

  

   NoLongerEvil Nest Programming
   Realistically do people need more than 4 per day? I don’t know. All I know is that when programming the old one I would always feel like “man I just need one more time setting to get this how I want it.”
  

  

   Fan cycle. This is something I have wanted forever. Ever since I heard someone, probably with a Nest, talk about it ten years ago or something. It let’s you say “if the heat or A/C don’t run for a full hour, spin the fan for a few minutes.” Why is that such a big deal? Well, in a house, especially with multiple floors, the spot with the thermostat is one temperature, but there are going to be a whole range of other temperatures everywhere else. Colder in the basement, hotter upstairs, maybe cooler in that one room and hotter where the sun shines in the windows, etc. Not only does this help to normalize temperatures by moving the air around, but it also keeps the air clean and fresh by running it through your air filter even when heating and cooling isn’t needed.
  

  

   Learning. I don’t yet know if I care about this. Apparently the thermostat will take notice if you keep turning up or down the set point, and eventually it will adjust your daily schedule based on that behavior. I have this enabled for now and will be curious to see if it works or is annoying.
  

  

   Other. It gets the date, time and outside temperature from Home Assistant - pretty cool! It also has a built in humidity sensor.
   NoLongerEvil Nest Programming
  

  

   Home Assistant
  

  

   I mentioned that I installed NoLongerEvil as an addon in Home Assistant. This is not the only option - you can run it separately with or without Home Assistant, and you can even use a free cloud service from NLE if you aren’t into self-hosting. In that case you are relying on NLE to keep their cloud bills paid and stuff. As an already prolific self-hoster, I definitely wanted to go that route.
  

  

   In addition to the NLE screen where I can see status and set the schedule, it was also easy to add a climate card to my dashboard for family use. This card allows easy access from our phones in the Home Assistant App to tick up or down the temperature, and change the mode (like go from heating to cooling or off). This is great because it both makes the thermostat available to everyone who I decide to give an Home Assistant account to, through their phone. And because Home Assistant is accessible from anywhere, we can tweak the house settings from anywhere in the house or even away from home. Driving home in a blizzard and really want the house nice and toasty when you get there? No problem.
  

  

   More than just remote control, all the same core functions available from the climate card can be added to Home Assistant automations. I may or may not ever add automations but for someone already using them to turn on and off lights, send notifications, etc., this would not be difficult. I just haven’t thought of anything I need to automate yet. But it gives me a nice feeling knowing I can have so much control over the device I purchased.
  

  

   Conclusion
  

  

   It’s up and working, the heating kicked on right on schedule this morning to warm up the house before clock alarms sounded. I gave the family a super quick 2-minute demo of how to use the wall unit and how to pull up the card in Home Assistant. No questions, a little bit of praise (for the phone control, the money saved, and keeping hardware out of a landfill). It seems like a lot of effort for such a small result, but it goes so much beyond this. It’s going to end up being countless little things for years to come. It’s going to be turning things down/off on a road trip because we forgot before leaving the house. It’s going to be ticking up the heat when we are all in the basement playing a board game and feeling chilly. Or a hundred other scenarios that will happen.
  

  

   Would I do it all again? Yes for sure. Especially running a C Wire as that opens the door to so many options and frees me from being worried a pair of AA batteries will die during a very inopportune time. The Nest was one choice of many, but I knew I wanted something that would tie directly into Home Assistant. Once you control your home automation it is nearly impossible to “go back” or accept a corporate cloud solution; this was a must.
  

  

   By the way, I typed this whole thing up by hand - no AI writing here. I even left a few typos in “on purpose” to prove it (I did try to fix most of them LOL). If you appreciate my writing feel free to scroll to the top and hit “buy me a coffee” at the top of the page.
  

 




        

      

    
    

        

          
Security updates for Tuesday

        

        

          Linux Weekly News
        

	

	  lwn.net
	

        

          2026-11-10 09:03:54
        

        

          
          

            Security updates have been issued by AlmaLinux (curl, dpdk, glibc, kernel, nodejs-nodemon, nodejs22, nodejs24, nodejs:18, nodejs:22, patch, qt5, qt5-qtdeclarative, ruby, ruby4.0, ruby:3.3, ruby:4.0, squid:4, tomcat, util-linux, and webkit2gtk3), Debian (symfony and tomcat10), Fedora (bind, dnf5, ker...
          

        

        

          
Original Article

          

 

  
   
    
     Dist.
    
    
     ID
    
    
     Release
    
    
     Package
    
    
     Date
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96092
     
    
    
     10
    
    
     curl
    
    
     2026-11-09
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96083
     
    
    
     8
    
    
     dpdk
    
    
     2026-11-09
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96087
     
    
    
     8
    
    
     glibc
    
    
     2026-11-10
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:93413
     
    
    
     10
    
    
     kernel
    
    
     2026-11-10
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:93412
     
    
    
     9
    
    
     kernel
    
    
     2026-11-10
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96236
     
    
    
     10
    
    
     nodejs-nodemon
    
    
     2026-11-10
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96094
     
    
    
     10
    
    
     nodejs22
    
    
     2026-11-10
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96088
     
    
    
     10
    
    
     nodejs24
    
    
     2026-11-10
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2023:4536
     
    
    
     8
    
    
     nodejs:18
    
    
     2026-11-09
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96234
     
    
    
     9
    
    
     nodejs:22
    
    
     2026-11-10
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96215
     
    
    
     8
    
    
     patch
    
    
     2026-11-10
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2023:6369
     
    
    
     9
    
    
     qt5
    
    
     2026-11-09
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96075
     
    
    
     8
    
    
     qt5-qtdeclarative
    
    
     2026-11-10
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96235
     
    
    
     10
    
    
     ruby
    
    
     2026-11-10
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96067
     
    
    
     9
    
    
     ruby
    
    
     2026-11-09
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96233
     
    
    
     10
    
    
     ruby4.0
    
    
     2026-11-09
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96068
     
    
    
     9
    
    
     ruby:3.3
    
    
     2026-11-09
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96120
     
    
    
     9
    
    
     ruby:4.0
    
    
     2026-11-09
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96078
     
    
    
     8
    
    
     squid:4
    
    
     2026-11-09
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:92862
     
    
    
     10
    
    
     tomcat
    
    
     2026-11-10
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96212
     
    
    
     8
    
    
     util-linux
    
    
     2026-11-09
    
   
   
    
     AlmaLinux
    
    
     
      ALSA-2026:96080
     
    
    
     8
    
    
     webkit2gtk3
    
    
     2026-11-09
    
   
   
    
     Debian
    
    
     
      DSA-6617-1
     
    
    
     stable
    
    
     symfony
    
    
     2026-11-09
    
   
   
    
     Debian
    
    
     
      DLA-4889-1
     
    
    
     LTS
    
    
     tomcat10
    
    
     2026-11-09
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-cf9d4ec5e6
     
    
    
     F44
    
    
     bind
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-5879bc27e1
     
    
    
     F43
    
    
     dnf5
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-1028a81d8a
     
    
    
     F43
    
    
     kernel
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-0e28591060
     
    
    
     F44
    
    
     kernel
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-655049a906
     
    
    
     F45
    
    
     kernel
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-1028a81d8a
     
    
    
     F43
    
    
     kernel-headers
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-0e28591060
     
    
    
     F44
    
    
     kernel-headers
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-655049a906
     
    
    
     F45
    
    
     kernel-headers
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-d657495ea3
     
    
    
     F44
    
    
     libmodulemd
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-946f33e2c8
     
    
    
     F45
    
    
     libmodulemd
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     maturin
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-a3a026d9ff
     
    
    
     F43
    
    
     perl-CGI
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-516e427bac
     
    
    
     F44
    
    
     perl-CGI
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-a04615c725
     
    
    
     F45
    
    
     perl-CGI
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-3cb8ce0117
     
    
    
     F43
    
    
     perl-Net-IDN-Encode
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-effb380a7c
     
    
    
     F44
    
    
     perl-Net-IDN-Encode
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-f6acaf8756
     
    
    
     F45
    
    
     perl-Net-IDN-Encode
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-092670ec3e
     
    
    
     F43
    
    
     perl-Starlet
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-bd36d053a1
     
    
    
     F44
    
    
     perl-Starlet
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-7d9cd72397
     
    
    
     F45
    
    
     perl-Starlet
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     python-jiter
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     python-pydantic-core
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     python-pysequoia
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-1520dedf55
     
    
    
     F43
    
    
     python3-docs
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-f3fe9323aa
     
    
    
     F45
    
    
     python3-docs
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-1520dedf55
     
    
    
     F43
    
    
     python3.14
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-f3fe9323aa
     
    
    
     F45
    
    
     python3.15
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     ruff
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     rust-afterburn
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     rust-astral_async_zip
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     rust-clearscreen
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     rust-jiter
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     rust-lzma-rust2
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     rust-mailparse
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     rust-pyo3-introspection
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     rust-python-pkginfo
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     rust-serde_json
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     rust-testresult
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     rust-zip
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     selenium-manager
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     ty
    
    
     2026-11-10
    
   
   
    
     Fedora
    
    
     
      FEDORA-2026-2b0f14aa7b
     
    
    
     F45
    
    
     uutils-coreutils
    
    
     2026-11-10
    
   
   
    
     Mageia
    
    
     
      MGASA-2026-0581
     
    
    
     10
    
    
     glibc
    
    
     2026-11-09
    
   
   
    
     Mageia
    
    
     
      MGASA-2026-0582
     
    
    
     10
    
    
     packages
    
    
     2026-11-09
    
   
   
    
     Mageia
    
    
     
      MGASA-2026-0585
     
    
    
     10
    
    
     php-smarty
    
    
     2026-11-09
    
   
   
    
     Mageia
    
    
     
      MGASA-2026-0584
     
    
    
     10
    
    
     python-aiohttp
    
    
     2026-11-09
    
   
   
    
     Mageia
    
    
     
      MGASA-2026-0583
     
    
    
     10
    
    
     thunderbird
    
    
     2026-11-09
    
   
   
    
     Oracle
    
    
     
      ELSA-2026-96092
     
    
    
     OL10
    
    
     curl
    
    
     2026-11-09
    
   
   
    
     Oracle
    
    
     
      ELSA-2026-83496
     
    
    
     OL7
    
    
     firefox
    
    
     2026-11-09
    
   
   
    
     Oracle
    
    
     
      ELSA-2026-92363
     
    
    
     OL7
    
    
     firefox
    
    
     2026-11-09
    
   
   
    
     Oracle
    
    
     
      ELSA-2026-73425
     
    
    
     OL8
    
    
     gdb
    
    
     2026-11-09
    
   
   
    
     Oracle
    
    
     
      ELSA-2026-76781
     
    
    
     OL10
    
    
     glibc
    
    
     2026-11-09
    
   
   
    
     Oracle
    
    
     
      ELSA-2026-95618
     
    
    
     OL9
    
    
     glibc
    
    
     2026-11-09
    
   
   
    
     Oracle
    
    
     
      ELSA-2026-95212
     
    
    
     OL8
    
    
     kernel
    
    
     2026-11-09
    
   
   
    
     Oracle
    
    
     
      ELSA-2026-500570
     
    
    
     OL8
    
    
     oVirt 4.5 ovirt-engine-wildfly
    
    
     2026-11-09
    
   
   
    
     Oracle
    
    
     
      ELSA-2026-500571
     
    
    
     OL9
    
    
     oVirt 4.5 ovirt-engine-wildfly
    
    
     2026-11-09
    
   
   
    
     Oracle
    
    
     
      ELSA-2026-93471
     
    
    
     OL8
    
    
     perl-YAML:1.24
    
    
     2026-11-09
    
   
   
    
     Oracle
    
    
     
      ELSA-2026-95725
     
    
    
     OL8
    
    
     tesseract
    
    
     2026-11-09
    
   
   
    
     Slackware
    
    
     
      SSA:2026-313-01
     
    
    
    
    
     krb5
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5141-1
     
    
    
     SLE12
    
    
     PackageKit
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5142-1
     
    
    
     SLE15 oS15.4
    
    
     PackageKit
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5144-1
     
    
    
     SLE15 oS15.5
    
    
     PackageKit
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5143-1
     
    
    
     SLE15 oS15.6
    
    
     PackageKit
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24618-1
     
    
    
     SLE16.1
    
    
     ansible-core
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24540-1
     
    
    
     SLE16.1
    
    
     apr-util
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      openSUSE-SU-2026:22232-1
     
    
    
     oS16.1
    
    
     apr-util
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5134-1
     
    
    
     SLE15
    
    
     aspell
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      openSUSE-SU-2026:12260-1
     
    
    
     TW
    
    
     buildpacks-cli
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5135-1
     
    
    
     SLE15 SLE5.5 SLE-m5.5 oS15.5
    
    
     dpdk22
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5145-1
     
    
    
     SLE15 oS15.4
    
    
     firefox
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      openSUSE-SU-2026:12259-1
     
    
    
     TW
    
    
     firefox
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      openSUSE-SU-2026:12261-1
     
    
    
     TW
    
    
     git-bug
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:4348-2
     
    
    
     SLE12
    
    
     glib2
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24616-1
     
    
    
     SLE16.1
    
    
     google-cloud-sap-agent
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24615-1
     
    
    
     SLE16.1
    
    
     haproxy
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24541-1
     
    
    
     SLE16.1
    
    
     jsoup
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24543-1
     
    
    
     SLE16.1
    
    
     kernel
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5136-1
     
    
    
     SLE12
    
    
     krb5
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24545-1
     
    
    
     SLE16.1
    
    
     libXtst
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5131-1
     
    
    
     SLE15
    
    
     libjxl
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24546-1
     
    
    
     SLE16.1
    
    
     librsvg
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      openSUSE-SU-2026:12252-1
     
    
    
     TW
    
    
     libruby4_0-4_0
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      openSUSE-SU-2026:12257-1
     
    
    
     TW
    
    
     libunbound8
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24548-1
     
    
    
     SLE16.1
    
    
     nodejs24
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24547-1
     
    
    
     SLE16.1
    
    
     nvidia-open-driver-G07-signed
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24544-1
     
    
    
     SLE16.1
    
    
     perl-XS-Parse-Keyword
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5133-1
     
    
    
     SLE15 oS15.6
    
    
     poppler
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24542-1
     
    
    
     SLE16.1
    
    
     python-Brotli
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5137-1
     
    
    
     SLE12
    
    
     python
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24613-1
     
    
    
     SLE16.1
    
    
     rsyslog
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      openSUSE-SU-2026:12253-1
     
    
    
     TW
    
    
     tekton-cli
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      openSUSE-SU-2026:12254-1
     
    
    
     TW
    
    
     tomcat
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      openSUSE-SU-2026:12255-1
     
    
    
     TW
    
    
     tomcat10
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      openSUSE-SU-2026:12256-1
     
    
    
     TW
    
    
     tomcat11
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      openSUSE-SU-2026:22233-1
     
    
    
     oS16.1
    
    
     trivy
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:24539-1
     
    
    
     SLE16.1
    
    
     udisks2
    
    
     2026-11-10
    
   
   
    
     SUSE
    
    
     
      openSUSE-SU-2026:22231-1
     
    
    
     oS16.1
    
    
     udisks2
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5139-1
     
    
    
     SLE12
    
    
     xen
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5140-1
     
    
    
     SLE15 oS15.6
    
    
     xen
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      SUSE-SU-2026:5138-1
     
    
    
     SLE15
    
    
     zchunk
    
    
     2026-11-09
    
   
   
    
     SUSE
    
    
     
      openSUSE-SU-2026:12258-1
     
    
    
     TW
    
    
     zk
    
    
     2026-11-09
    
   
   
    
     Ubuntu
    
    
     
      USN-9016-1
     
    
    
     14.04 16.04 18.04 20.04 22.04 24.04 26.04 26.10
    
    
     apache2
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9001-2
     
    
    
     18.04 20.04
    
    
     ca-certificates
    
    
     2026-11-09
    
   
   
    
     Ubuntu
    
    
     
      USN-9013-1
     
    
    
     16.04 18.04 20.04 22.04 24.04 26.04 26.10
    
    
     fetchmail
    
    
     2026-11-09
    
   
   
    
     Ubuntu
    
    
     
      USN-9007-1
     
    
    
     24.04 26.04 26.10
    
    
     freerdp3
    
    
     2026-11-09
    
   
   
    
     Ubuntu
    
    
     
      USN-9035-1
     
    
    
     14.04
    
    
     kernel
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9017-1
     
    
    
     14.04 16.04 18.04 20.04 22.04 24.04 26.04 26.10
    
    
     libgphoto2
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9012-1
     
    
    
     26.04
    
    
     libheif
    
    
     2026-11-09
    
   
   
    
     Ubuntu
    
    
     
      USN-9008-1
     
    
    
     22.04 24.04 26.04 26.10
    
    
     libnfs
    
    
     2026-11-09
    
   
   
    
     Ubuntu
    
    
     
      USN-8890-3
     
    
    
     24.04 26.04 26.10
    
    
     libsoup3
    
    
     2026-11-09
    
   
   
    
     Ubuntu
    
    
     
      USN-9027-1
     
    
    
     20.04 22.04
    
    
     linux, linux-aws, linux-aws-5.15, linux-aws-fips, linux-azure, linux-azure-5.15, linux-azure-fde-5.15, linux-azure-fips, linux-gcp, linux-gcp-5.15, linux-gcp-fips, linux-gke, linux-gkeop, linux-hwe-5.15, linux-ibm, linux-ibm-5.15, linux-intel-iot-realtime, linux-intel-iotg, linux-intel-iotg-5.15, linux-kvm, linux-lowlatency, linux-lowlatency-hwe-5.15, linux-nvidia, linux-nvidia-tegra, linux-nvidia-tegra-5.15, linux-oracle, linux-oracle-5.15, linux-realtime
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9032-1
     
    
    
     14.04 16.04 18.04
    
    
     linux, linux-aws, linux-aws-fips, linux-aws-hwe, linux-azure, linux-azure-4.15, linux-azure-fips, linux-fips, linux-gcp, linux-gcp-4.15, linux-gcp-fips, linux-hwe, linux-kvm, linux-oracle
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9030-1
     
    
    
     18.04 20.04
    
    
     linux, linux-aws, linux-aws-fips, linux-azure, linux-azure-5.4, linux-azure-fips, linux-bluefield, linux-fips, linux-gcp, linux-gcp-5.4, linux-gcp-fips, linux-hwe-5.4, linux-ibm, linux-ibm-5.4, linux-iot, linux-kvm, linux-oracle, linux-oracle-5.4, linux-xilinx-zynqmp
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9022-1
     
    
    
     24.04
    
    
     linux, linux-aws, linux-azure, linux-azure-fips, linux-gcp, linux-gke, linux-ibm, linux-lowlatency, linux-oracle, linux-vmware
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9018-1
     
    
    
     26.04
    
    
     linux, linux-aws, linux-gcp, linux-ibm, linux-oem-7.0, linux-oracle
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9033-1
     
    
    
     14.04 16.04
    
    
     linux, linux-aws, linux-kvm, linux-lts-xenial
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9034-1
     
    
    
     14.04
    
    
     linux-aws
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9031-1
     
    
    
     18.04 20.04
    
    
     linux-aws-5.4, linux-raspi, linux-raspi-5.4
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9024-1
     
    
    
     22.04 24.04
    
    
     linux-aws-6.8, linux-gcp-6.8, linux-ibm-6.8, linux-lowlatency-hwe-6.8, linux-nvidia, linux-realtime-6.8
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9020-1
     
    
    
     24.04 26.04
    
    
     linux-aws-7.0, linux-azure-fde, linux-azure-fde-7.0, linux-gcp-7.0, linux-gke, linux-oracle-7.0, linux-realtime
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9023-1
     
    
    
     24.04
    
    
     linux-aws-fips, linux-gcp-fips, linux-gkeop, linux-realtime
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9019-1
     
    
    
     26.04
    
    
     linux-azure
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9026-1
     
    
    
     22.04
    
    
     linux-azure-6.8, linux-azure-fde-6.8
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9028-1
     
    
    
     22.04
    
    
     linux-azure-fde
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9025-1
     
    
    
     22.04 24.04
    
    
     linux-oracle-6.8, linux-raspi, linux-raspi-realtime
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9029-1
     
    
    
     22.04
    
    
     linux-raspi
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9014-1
     
    
    
     18.04 20.04 22.04 24.04 26.04 26.10
    
    
     openjdk-17
    
    
     2026-11-09
    
   
   
    
     Ubuntu
    
    
     
      USN-9015-1
     
    
    
     20.04 22.04 24.04 26.04 26.10
    
    
     openjdk-21
    
    
     2026-11-09
    
   
   
    
     Ubuntu
    
    
     
      USN-9004-1
     
    
    
     22.04 24.04 26.04 26.10
    
    
     openjdk-25
    
    
     2026-11-09
    
   
   
    
     Ubuntu
    
    
     
      USN-9005-1
     
    
    
     26.10
    
    
     openjdk-27
    
    
     2026-11-09
    
   
   
    
     Ubuntu
    
    
     
      USN-9009-1
     
    
    
     16.04 18.04 20.04 22.04 24.04 26.04 26.10
    
    
     openjdk-8
    
    
     2026-11-09
    
   
   
    
     Ubuntu
    
    
     
      USN-9010-1
     
    
    
     18.04 20.04 22.04 24.04 26.04 26.10
    
    
     openjdk-lts
    
    
     2026-11-09
    
   
   
    
     Ubuntu
    
    
     
      USN-9006-1
     
    
    
     14.04 16.04 18.04 20.04 22.04 24.04 26.04 26.10
    
    
     perl
    
    
     2026-11-10
    
   
   
    
     Ubuntu
    
    
     
      USN-9011-1
     
    
    
     14.04 16.04 18.04 20.04 22.04 24.04 26.04 26.10
    
    
     pyasn1
    
    
     2026-11-09
    
   
  
 




        

      

    
    

        

          
Compress any LLM 3x in one click,near-lossless,in under 50 MB RAM

        

        

          Hacker News
        

	

	  neuracryption.com
	

        

          2026-11-10 08:51:51
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  
  

   

    01. Architectural Motivation & The Physics of the Memory Wall
   

   

    To understand why generative artificial intelligence models crawl to an agonizing halt on edge devices, one must look past algorithmic abstractions and confront the underlying solid-state physics of digital silicon. Consider the typical machine learning workstation or consumer laptop. It is equipped with a modern graphics processing unit such as the NVIDIA GeForce RTX 3050 Ti Mobile (GA107 silicon). On paper, this processor is astonishing: it houses 2,560 CUDA cores and 80 second-generation Tensor Cores, delivering an aggregate compute density of 29.8 TFLOPS in half-precision floating-point arithmetic. In theory, it can execute nearly thirty trillion numerical calculations every second.
   

   

    Yet, when an engineer attempts to deploy a modest 7-billion parameter language model in uncompressed FP16 precision, the system collapses immediately.
   

   

    The root cause is the
    
     memory wall
    
    : a severe physical asymmetry where computational density on GPU dies has scaled exponentially following Moore's Law, while the external memory interface that transports numbers from dynamic random-access memory (GDDR6 VRAM) into arithmetic logic units has hit hard thermal and electrical signaling limits. On consumer silicon, that interface is typically 128 bits wide, providing an aggregate memory bandwidth of 192.0 gigabytes per second.
   

   

    

     During autoregressive token generation, a language model emits exactly one token at a time ($M = 1$). To predict that single token, the GPU cannot reuse loaded weights across a sequence batch. It must sweep every single parameter matrix of the network from high-latency global VRAM into on-chip register files. For a single token, operational arithmetic intensity drops to approximately
     
      1 FLOP per byte loaded
     
     .
    

   

   

    At 192.0 GB/s, reading an uncompressed 14 GB model once requires approximately 73 milliseconds. This caps the physical theoretical ceiling of generation to less than 14 tokens per second, leaving more than 95% of the GPU's computational tensor cores completely starved of data, idling while bytes traverse copper traces.
   

   

    Even worse, consumer edge GPUs feature strict physical VRAM limits, typically capped at 4GB (3,770.6 MiB addressable ceiling). Because a 14 GB or 7 GB model physically cannot fit inside 4GB of video memory, traditional execution frameworks offload layers to host system RAM across the PCIe expansion bus. A standard PCIe Gen3 x4 connection provides an effective transfer rate of roughly 3.94 GB/s. Offloading parameters across this bus causes generation speeds to crater to
    
     0.28 tokens per second
    
    : an unusable latency for interactive speech interfaces, autonomous robotics, or real-time telecommunications.
   

   

    Prior post-training quantization schemes (such as GPTQ, AWQ, and SmoothQuant) attempted to compress weights to 4-bit representations, but introduced three critical architectural bottlenecks:
   

   
    
    
  • 
     
      Domain-Shift Brittleness:
     
     Quantization grids calibrated on synthetic or generic text corpora (such as WikiText-2 or C4) experience catastrophic perplexity degradation when exposed to telephone speech transcripts, structured JSON schemas, medical terminology, or foreign languages.
    
    • 
    
  • 
     
      High Preprocessing Latency:
     
     Calculating empirical second-order Hessian statistics requires minutes to hours of forward passes over GPU hardware, making on-device dynamic compression impossible.
    
    • 
    
  • 
     
      Structural Incompatibility with Recurrent State-Space Models:
     
     Modern architectures featuring non-transformer layers (such as Mamba-2, ConvNet/SSM hybrids, and Liquid Neural Networks) break standard transformer calibration assumptions, resulting in severe runtime failures.
    
    • 
   

   

    SPECTRA resolves these constraints through an architecture-agnostic framework grounded in Shannon source coding theory, calibration-free topological saliency extraction, Group-32 microscaling, and register-fused Triton GPU kernels.
   

   
   

    

     Table 0: Master Architectural Taxonomy and Methodological Foundations of the SPECTRA Engine
    

    

     Comprehensive taxonomy mapping SPECTRA core subsystems to mathematical principles and execution hardware.
    

    

     
      

       
        Subsystem Component
       
       
        Mathematical / Physical Principle
       
       
        Algorithmic Mechanism
       
       
        Hardware Execution Target
       
      

     
     
      

       
        
         Rate-Distortion Compressor
        
       
       
        Continuous Shannon Rate-Distortion $R(D)$
       
       
        Group-32 asymmetric 4-bit uniform grid with zero points
       
       
        CPU / Host Memory (Zero-GPU overhead)
       
      

      

       
        
         AST Sensitivity Pre-Scanner
        
       
       
        Asymptotic Fisher Information Curvature $F_{jj} \propto |\gamma_j|^2$
       
       
        Direct AST traversal extracting LayerNorm/RMSNorm scales
       
       
        Host Python Runtime (< 50 ms latency)
       
      

      

       
        
         HDSQ-Ultra Outlier Isolation
        
       
       
        Fourth-moment population kurtosis $\kappa > 3.0$
       
       
        Adaptive outlier ratio $r \le 3.0\%$ with 32-bit index packing
       
       
        Contiguous pinned host memory / TRDC binary
       
      

      

       
        
         Fused W4A16 GEMV Kernel
        
       
       
        Arithmetic intensity maximization ($M = 1$)
       
       
        In-register dual nibble unpacking, scaling, and FMA accumulation
       
       
        GPU Register Files / Vector SRAM ($M = 1$)
       
      

      

       
        
         Batched W4A16 GEMM Kernel
        
       
       
        Tensor Core compute density ($M \ge 2$)
       
       
        2D output tiling with $L2$ cache swizzling and Tensor Cores
       
       
        Ampere Tensor Cores ($tl.dot$ instructions)
       
      

      

       
        
         SpectraFusedEmbedding
        
       
       
        Static parameter memory footprint reduction
       
       
        Dynamic row-gather dequantization for large vocabularies
       
       
        On-chip VRAM (Saves 69.4% embedding RAM)
       
      

      

       
        
         PingPongLayerOffloader
        
       
       
        PCIe bus hiding via latency overlapping
       
       
        Double-buffered asynchronous CUDA DMA streams
       
       
        PCIe Gen3/4 x4 bus + dual GPU staging slots
       
      

      

       
        
         SpectraQuantizedCache
        
       
       
        Dynamic context memory trajectory bounding
       
       
        Group-32 microscaled 4-bit KV Cache allocations
       
       
        GPU VRAM (8,192 tokens on 4GB hardware)
       
      

      

       
        
         TRDC Serialization Format
        
       
       
        Zero-copy memory mapping via POSIX $mmap$
       
       
        24-byte fixed binary header + flat tensor buffers
       
       
        Direct-to-GPU streaming ($TRDC4B01$)
       
      

     
    

   

  

  
  

   

    02. Information Theory & The Mechanics of Functional Losslessness
   

   

    2.1 Lossless Bitstream Entropy Bounds vs. Continuous Parameter Rate-Distortion
   

   

    To understand why traditional compression formats cannot shrink neural networks below the memory wall, we examine the theoretical limits of bit-exact representation through classical information theory. Under Claude Shannon's landmark 1948 Source Coding Theorem, the minimum expected code length $L$ required to losslessly encode a discrete symbol sequence $W$ is bounded strictly by its Shannon entropy $H(W)$:
   

   

    

     Shannon Source Coding Theorem (Discrete Entropy Bound)
    

    

     $$L \ge H(W) = - \sum_{i=1}^{M} p(w_i) \log_2 p(w_i)$$
    

    

     Where $p(w_i)$ is the empirical probability of occurrence of parameter value $w_i$.
    

   

   

    In modern foundation models, learned weight tensors are stored in IEEE 754 half-precision (FP16) or Brain Floating Point (BF16) formats. A 16-bit floating-point number factorizes into a 1-bit sign $s \in \{0, 1\}$, an $E$-bit exponent $e \in \{0, 1\}^E$, and an $M$-bit fractional significand or mantissa $m \in \{0, 1\}^M$:
   

   

    

     Floating-Point Representation Decomposition
    

    

     $$w = (-1)^s \cdot 2^{e - \text{bias}} \cdot \left(1 + \sum_{k=1}^{M} m_k 2^{-k}\right)$$
    

    

     Standard IEEE 754 FP16 ($E = 5, M = 10$) and BF16 ($E = 8, M = 7$) bit-field factorization.
    

   

   

    Empirical entropy audits across deep parameter manifolds reveal a fundamental structural asymmetry in the information density of these fields:
   

   
    
    
  • 
     
      Sign Bit Entropy:
     
     Distributed near-symmetrically across positive and negative domains, exhibiting near-maximal discrete entropy: $H(s) \approx 1.0\text{ bit}$.
    
    • 
    
  • 
     
      Exponent Vector Entropy:
     
     Displays strong clustering around layer-specific dynamic scales, yielding low discrete entropy: $H(e) \in [1.6, 2.7]\text{ bits}$.
    
    • 
    
  • 
     
      Fractional Mantissa Entropy:
     
     In overparameterized neural networks, stochastic gradient updates fill the lowest-order mantissa bits with near-uniform noise. In BF16 ($M = 7$), empirical mantissa entropy is $H(m) \approx 6.8\text{ to }7.0\text{ bits}$; in FP16 ($M = 10$), it reaches $H(m) \approx 9.5\text{ to }9.9\text{ bits}$.
    
    • 
   

   

    Summing these components demonstrates that the aggregate discrete entropy of floating-point weight tensors is approximately 10.5 bits in BF16 and 13.5 bits in FP16. Consequently, any general-purpose or floating-point lossless bitstream compressor (such as zstd, LZ4, or fpzip) is fundamentally bounded to a lossless compression ratio of:
   

   

    

     Physical Limits of Bit-Exact Lossless Compression
    

    

     $$R_{\text{lossless}}(\text{FP16}) = \frac{16}{H(W_{\text{FP16}})} \approx \frac{16}{13.5} \approx 1.19\times, \qquad R_{\text{lossless}}(\text{BF16}) = \frac{16}{H(W_{\text{BF16}})} \approx \frac{16}{10.5} \approx 1.52\times$$
    

    

     Shannon's ceiling proves that no lossless algorithm can compress FP16 model weights past 1.19x.
    

   

   

    Because lossless compression cannot exceed $1.52\times$, compression ratios between $2.80\times$ and $3.31\times$ mathematically mandate transitioning to
    
     Shannon Rate-Distortion Theory ($R(D)$)
    
    . Under rate-distortion theory, continuous weight distributions are mapped to discrete microscaled states while bounding functional task distortion.
   

   

    2.2 Continuous Rate-Distortion Theory and Granular vs. Clipping Distortion
   

   

    To analyze non-invertible tensor compression, we examine the continuous rate-distortion function $R(D)$, which characterizes the minimal bit rate $R$ required to represent a source distribution within an expected distortion threshold $D$:
   

   

    

     Continuous Rate-Distortion Function
    

    

     $$R(D) = \min_{p(\hat{w}|w): \mathbb{E}[d(w, \hat{w})] \le D} I(W; \hat{W}) = \frac{1}{2} \log_2 \left(\frac{\sigma_w^2}{D}\right), \qquad 0 \le D \le \sigma_w^2$$
    

    

     Lower bound for zero-mean Gaussian source under mean-squared error distortion $d(w, \hat{w}) = (w - \hat{w})^2$.
    

   

   

    In practical uniform $b$-bit quantization parameterized by clipping threshold $\alpha$ and group step size $\Delta = \frac{2\alpha}{2^b - 1}$, total expected distortion $D(\Delta, \alpha)$ factorizes into two distinct components:
   

   

    

     Distortion Factorization: Granular vs. Clipping Overload
    

    

     $$D(\Delta, \alpha) = D_{\text{granular}}(\Delta, \alpha) + D_{\text{clipping}}(\alpha) = \frac{\Delta^2}{12} \int_{-\alpha}^{\alpha} p(w)\,dw + 2 \int_{\alpha}^{\infty} (w - \alpha)^2 p(w)\,dw$$
    

    

     Illustrating the fundamental trade-off between quantization resolution and outlier clipping.
    

   

   

    When learned weight tensors exhibit heavy tails (kurtosis $\kappa \gg 3.0$), this distortion trade-off breaks down catastrophically. Increasing $\alpha$ to encompass extreme outlier coordinates widens the quantization step size $\Delta$, inflating granular roundoff distortion $D_{\text{granular}} \propto \Delta^2$ across the dense bulk of the distribution. Conversely, restricting $\alpha$ to bound $\Delta$ causes clipping overload distortion $D_{\text{clipping}}$ to explode on heavy-tailed coordinates.
   

   

    

     Fourth Standardized Moment (Population Kurtosis)
    

    

     $$\kappa = \frac{\frac{1}{d} \sum_{i=1}^{d} (w_i - \mu)^4}{\sigma^4} > 3.0$$
    

    

     Measuring parameter leptokurtosis across linear projection layers in foundation models.
    

   

   

    2.3 Architectural Proofs: Propositions 1, 2, and 3
   

   

    We now establish the three formal mathematical propositions that govern channel outlier isolation, Group-32 reconstruction error bounds, and closed-form Gaussian noise predictions within the SPECTRA engine.
   

   
   

    

     
      Statement:
     
     For any $K$ channel saliency values $S_1, \dots, S_K$, the population fourth-moment kurtosis satisfies $\kappa \le K$.
    

    

     
      Formal Proof:
     
     Let $z_j = (S_j - \mu_S)/\sigma_S$ denote the standardized channel saliencies, where $\mu_S = \frac{1}{K} \sum_{j=1}^K S_j$ and $\sigma_S^2 = \frac{1}{K} \sum_{j=1}^K (S_j - \mu_S)^2$. By construction, $\sum_{j=1}^K z_j^2 = K$. By the Cauchy-Schwarz inequality on the vector of squared terms $(z_1^2, \dots, z_K^2)$ and the all-ones vector:
    

    

     $$\sum_{j=1}^K z_j^4 \le \left(\sum_{j=1}^K z_j^2\right)^2 = K^2$$
    

    

     Dividing both sides by $K$ yields the population kurtosis bound:
    

    

     $$\kappa = \frac{1}{K} \sum_{j=1}^K z_j^4 \le \frac{K^2}{K} = K$$
    

    

     
      Consequence:
     
     Under the SPECTRA adaptive rule $r = 0.01(1 + 0.15 \ln(1 + \max(0, \kappa - 3)))$, the outlier ratio satisfies $r \le 0.01(1 + 0.15 \ln(K - 2))$. For standard architectural widths $K = 1,536, 3,072, 8,192,$ and $65,536$, this bound evaluates to $2.10\%, 2.20\%, 2.35\%,$ and $2.66\%$, respectively. The $3.0\%$ hard cap is reached only when $\kappa$ exceeds approximately $6.2 \times 10^5$, establishing that the 3.0% threshold serves as an asymptotic physical safety clamp.
    

   

   
   

    

     
      Statement:
     
     If a group of 32 weights contains both signs ($w_{\min} \le 0 \le w_{\max}$), every reconstructed weight $\hat{w}$ satisfies $|w - \hat{w}| \le s/2$, apart from the floating-point rounding of the scale $s$ itself to 16 bits.
    

    

     
      Formal Proof:
     
     Because $0$ lies within $[w_{\min}, w_{\max}]$, the zero-point formula $z = \text{round}(-w_{\min}/s)$ is not clipped to the boundary. The reconstruction grid points $(q - z)s$ for 4-bit integer codes $q \in \{0, 1, \dots, 15\}$ start within $s/2$ of $w_{\min}$ (at $q = 0$) and, since the scale is defined as $s = (w_{\max} - w_{\min})/15$, terminate within $s/2$ of $w_{\max}$ (at $q = 15$). Every weight $w \in [w_{\min}, w_{\max}]$ lies between consecutive grid points spaced by $s$, ensuring:
    

    

     $$|w - \hat{w}| \le \frac{s}{2}$$
    

    

     
      Remark:
     
     In deep neural networks with 32 weights per group, entirely one-sided groups are exceedingly rare (requiring all 32 independent weights to possess the same sign). In empirical audits across a $512 \times 1,024$ matrix, the observed maximum error divided by scale was $0.49999s$, confirming strict adherence to the $s/2$ bound.
    

   

   
   

    

     
      Statement:
     
     Suppose the 32 weights of a group are independent and Gaussian with standard deviation $\sigma$. Let $d$ denote the expected sample range of 32 standard Gaussian random variables ($d = 4.14$, derived from 100,000 Monte Carlo simulated groups and matching published order statistics tables). Then the expected scale is $s = d\sigma/15$, the quantization error is approximately uniform with variance $\sigma_{\text{err}}^2 = s^2/12$, and:
    

    

     $$\text{Relative Frobenius Error} = \frac{\sigma_{\text{err}}}{\sigma} = \frac{d}{15 \sqrt{12}} = \frac{4.14}{51.9615} \approx 7.97\%$$
    

    

     $$\text{SNR (dB)} = 10 \log_{10} \left(\frac{\sigma^2}{\sigma_{\text{err}}^2}\right) = 20 \log_{10} \left(\frac{15 \sqrt{12}}{d}\right) = 21.97\text{ dB}$$
    

    

     $$\text{Cosine Similarity} = \frac{\mathbb{E}[w \hat{w}]}{\sqrt{\mathbb{E}[w^2] \mathbb{E}[\hat{w}^2]}} \approx 1 - \frac{\epsilon^2}{2} = 1 - \frac{(0.0797)^2}{2} \approx 0.99682$$
    

    

     
      Verification against Simulation:
     
     A synthetic $2,048 \times 2,048$ Gaussian matrix evaluated under Group-32 yielded an empirical relative error of $8.08\%$, an SNR of $21.85\text{ dB}$, and a Cosine Similarity of $0.99676$, matching Proposition 3 within 0.11 percentage points of error and 0.12 dB. Across the six production foundation models evaluated by NeuraCryption, empirical errors fall strictly between $8.04\%$ and $8.32\%$ with SNRs between $21.59\text{ dB}$ and $21.89\text{ dB}$.
    

   

   

    2.4 Functional Representational Invariance and Parameter Hessian Eigenspectra
   

   

    Deep neural networks operate as continuous non-linear manifold mappings rather than fragile bitstream decoders. For a linear projection operator $y = xW$, where $x \in \mathbb{R}^{B \times K}$ denotes an incoming activation tensor and $W \in \mathbb{R}^{K \times N}$ represents the learned parameter matrix, the downstream objective function $\mathcal{L}$ is invariant to parameter perturbations $\Delta W$ that reside within the functional null-space of the operator.
   

   

    Expanding the task loss around the converged parameter optimum $W^*$ via second-order Taylor series approximation:
   

   

    

     Second-Order Taylor Series Perturbation Expansion
    

    

     $$\Delta \mathcal{L} \approx \text{Tr}\left((\nabla_W \mathcal{L})^T \Delta W\right) + \frac{1}{2} \text{vec}(\Delta W)^T H_W \text{vec}(\Delta W) + \mathcal{O}(\|\Delta W\|_F^3)$$
    

    

     At local convergence, first-order gradient $\nabla_W \mathcal{L} \approx 0$, leaving parameter Hessian $H_W$ dominant.
    

   

   

    The parameter Hessian $H_W = \mathbb{E}_{x \sim \mathcal{D}} [(x^T x) \otimes \nabla_a^2 \mathcal{L}]$ exhibits a heavily degenerate eigenspectrum characterized by power-law spectral decay: $\lambda_i \propto i^{-\alpha}$ with $\alpha > 1.5$. Decomposing the parameter space into the dominant eigensubspace $\mathcal{S}_\parallel$ spanned by the top-$k$ eigenvectors and the numerical null-space $\mathcal{S}_\perp$:
   

   

    

     Eigenspace Decomposition of Loss Perturbation
    

    

     $$\Delta \mathcal{L} \le \frac{1}{2} \lambda_{\max}(H_W) \|\Delta W_\parallel\|_F^2 + \frac{1}{2} \epsilon_{\text{null}} \|\Delta W_\perp\|_F^2, \qquad \epsilon_{\text{null}} \approx 0$$
    

    

     Because effective parameter dimension $d_{\text{eff}} = \text{Tr}(H_W)/\lambda_{\max} \ll d_{\text{total}}$, null-space perturbations do not shift logits.
    

   

   

    2.5 Mathematical and Empirical Criteria of Functional Representation Parity
   

   

    SPECTRA defines functional representation parity through three rigorous mathematical and empirical criteria:
   

   
    
    
  1. 
     
      Topological Candidate Preservation:
     
     The discrete $\arg\max$ trajectory across the vocabulary simplex remains statistically aligned between the uncompressed parameter matrix $W$ and the reconstructed tensor $\hat{W}$ throughout autoregressive sequence generation:
     
    
      
    
       \arg\max_{v \in \mathcal{V}} P(y_t = v \mid y_{
      
    
      
      
     
    
    
    2. 
    
  2. 
     
      Signal Fidelity Bounds:
     
     The reconstructed parameter matrix $\hat{W}$ maintains a Cosine Similarity exceeding 0.996 and an SNR surpassing 21.5 dB relative to uncompressed tensor $W$:
     
    
      \text{Cosine Similarity}(W, \hat{W}) = \frac{\langle W, \hat{W} \rangle}{\|W\|_F \|\hat{W}\|_F} \ge 0.996, \qquad \text{SNR (dB)} = 10 \log_{10} \left(\frac{\|W\|_F^2}{\|W - \hat{W}\|_F^2}\right) > 21.5\text{ dB}
     
    
    
    3. 
    
  3. 
     
      Downstream Reasoning Task Parity:
     
     Measured performance on formal multi-step scientific reasoning benchmarks (such as ARC-Challenge) maintains near-baseline retention (measured deltas within +0.42% to +0.85%), confirming that low-bit quantization preserves semantic problem-solving trajectories.
    
    4. 
   

   

    2.6 Lipschitz Stability of Normalization-Modulated Neural Projections
   

   

    In modern foundation architectures, linear projection layers are coupled directly to normalization operators such as Root Mean Square Normalization (RMSNorm) or Layer Normalization (LayerNorm). For an un-normalized feature vector $h \in \mathbb{R}^K$, RMSNorm computes:
   

   

    

     RMSNorm Activation Formulation
    

    

     $$\text{RMSNorm}(h) = \frac{h}{\sqrt{\frac{1}{K} \sum_{k=1}^K h_k^2 + \epsilon}} \odot \gamma$$
    

    

     Where $\gamma \in \mathbb{R}^K$ denotes the learned channel-wise affine scaling parameter vector.
    

   

   

    Evaluating the Euclidean norm of the normalized activation yields $\|\text{RMSNorm}(h)\|_2 \le \sqrt{K} \|\gamma\|_\infty$. Under a parameter perturbation $\Delta W = W - \hat{W}$, the output deviation $\Delta y = \text{RMSNorm}(h)\Delta W$ is strictly Lipschitz bounded:
   

   

    

     Lipschitz Output Perturbation Bound
    

    

     $$\|\Delta y\|_2 \le \|\text{RMSNorm}(h)\|_2 \|\Delta W\|_2 \le \sqrt{K} \|\gamma\|_\infty \|\Delta W\|_2$$
    

    

     Decomposing this bound proves that expected output variance in coordinate $j$ scales quadratically with $|\gamma_j|^2$.
    

   

  

  
  

   

    03. Algorithmic Architecture & The Compression Pipeline
   

   

    3.1 Calibration-Free Topological Saliency Mapping via Normalization Gain Routing
   

   

    Conventional post-training quantization pipelines (such as AWQ and GPTQ) rely on empirical calibration passes over reference text corpora to calculate activation covariance statistics $\mathbb{E}[X^T X]$. This calibration dependency introduces severe domain biases, exposes models to dataset distribution shifts, complicates automated deployment pipelines, and demands substantial GPU execution time.
   

   

    SPECTRA eliminates dynamic calibration passes by calculating channel saliency directly from the topological graph structure of the neural network. In modern Transformer and state-space architectures, linear projection layers are situated immediately downstream from normalization layers, such as Layer Normalization or Root Mean Square Normalization (RMSNorm). For an un-normalized activation vector $h \in \mathbb{R}^K$, RMSNorm evaluates:
   

   

    

     RMSNorm Activation Scaling
    

    

     $$\text{RMSNorm}(h) = \frac{h}{\sqrt{\frac{1}{K} \sum_{k=1}^K h_k^2 + \epsilon}} \odot \gamma$$
    

    

     Where $\gamma \in \mathbb{R}^K$ represents the learned channel-wise affine scaling parameter.
    

   

   

    During forward inference, the input arriving at the downstream linear projection $W \in \mathbb{R}^{K \times N}$ is precisely $x = \text{RMSNorm}(h)$. Because normalization standardizes the underlying hidden vector to unit spherical variance, the expected magnitude and dynamic scale of coordinate $j$ entering the weight matrix are governed entirely by the learned affine parameter $|\gamma_j|$.
   

   

    3.2 Topological Normalization Gain as a Calibration-Free Sensitivity Proxy
   

   

    In second-order quantization frameworks (such as GPTQ), the empirical Fisher Information Matrix $F \in \mathbb{R}^{d \times d}$ serves as an expectation-based proxy for parameter curvature: $F_{jj} = \mathbb{E}_{x,y} [(\partial \mathcal{L}/\partial W_{:,j})^2]$. For linear operators preceded immediately by normalization ($y = \text{RMSNorm}(h)W$), the gradient evaluates to $\frac{\partial \mathcal{L}}{\partial W_{:,j}} = x_j \cdot \frac{\partial \mathcal{L}}{\partial y}$. Under an isotropic activation approximation, the first-order input variance entering column $j$ scales with the square of the learned affine gain:
   

   

    

     Mathematical Derivation: Fisher Curvature Proportionality
    

    

     $$F_{jj} = \mathbb{E}[x_j^2] \cdot \mathbb{E}\left[\left(\frac{\partial \mathcal{L}}{\partial y}\right)^2\right] = |\gamma_j|^2 \cdot \mathbb{E}\left[\frac{h_j^2}{\frac{1}{K}\|h\|_2^2 + \epsilon}\right] \cdot C_{\text{layer}} \approx |\gamma_j|^2 \cdot C_{\text{layer}}$$
    

    

     Proving that the learned affine scale vector $\gamma$ analytically mirrors the parameter Hessian curvature diagonal.
    

   

   

    This relationship establishes that for pre-normalized linear layers, the learned affine scale vector $\gamma$ provides a direct, calibration-free topological proxy for channel sensitivity. For attention input projections ($q\_proj, k\_proj, v\_proj$) and MLP input layers ($gate\_proj, up\_proj$), channel saliency is evaluated as:
   

   

    

     SPECTRA Analytical Channel Saliency Metric
    

    

     $$S_j = |\gamma_j| \cdot \|W_{:,j}\|_2$$
    

    

     Combining learned affine curvature gain with the Euclidean $L2$-norm of weight column $j$.
    

   

   

    
     Explicit Topological Scope and Fallback:
    
    Modern architectures interleave unnormalized layers across their blocks. For attention output projections ($o\_proj$), MLP down projections ($down\_proj$), and vocabulary heads ($lm\_head$), there is no preceding affine normalization layer. As codified in Table 11 of the paper and implemented in
    
     
      compressor.py
     
    
    , the AST pre-scanner sets $\gamma_j = 1.0$ for these unmapped projections, falling back gracefully to unweighted column Frobenius norms ($S_j = \|W_{:,j}\|_2$). Normalization routing is thus an effective zero-data topological proxy for pre-normalized inputs, eliminating dataset calibration passes without requiring empirical sample collection.
   

   

    3.3 Excess Kurtosis Dynamics and Adaptive Sparsification Mechanics
   

   

    Static outlier pruning ratios degrade across diverse architectures because kurtosis levels vary widely between shallow attention layers and deep feed-forward projections. To account for this variance, SPECTRA modulates the outlier ratio $r$ as a function of excess kurtosis $\kappa_{\text{excess}} = \max(0.0, \kappa - 3.0)$:
   

   

    

     Adaptive Kurtosis-Modulated Outlier Allocation Rule
    

    

     $$r = \text{clamp}\left(r_{\text{base}} \cdot \left(1.0 + 0.15 \cdot \ln(1 + \kappa_{\text{excess}})\right), 0.005, 0.03\right)$$
    

    

     Where $r_{\text{base}} = 0.01$ denotes the baseline 1.0% outlier ratio.
    

   

   

    For mesokurtic channels ($\kappa \le 3.0$), the logarithmic term evaluates to zero, maintaining $r = 0.01$ to preserve high computational density. For leptokurtic channels ($\kappa \gg 10.0$), the logarithmic function expands $r$ gradually up to a strict 3.0% cap ($0.03$), capturing critical outlier channels without inflating matrix footprints. Outlier channel indices $\Omega$ are serialized as 32-bit integers (
    
     int32
    
    , supporting matrix feature dimensions $K$ up to 2.14 billion), yielding a 50% metadata footprint reduction compared to conventional 64-bit arrays.
   

   

    3.4 Microscaled Group-32 Quantization with Marlin-Interleaved Layout
   

   

    Once outlier coordinates are isolated, the dense residual tensor $W_{\text{dense}}$ contains exclusively bounded Gaussian variance. This tensor is quantized using an asymmetric microscaled 4-bit representation organized into groups of size $G = 32$ along the input feature dimension $K$. For each group $g \in \{0, \dots, (K/G) - 1\}$ in row $i \in \{0, \dots, N - 1\}$, local min and max parameters are extracted:
   

   

    

     Asymmetric Group-32 Microscaling Formulas
    

    

     $$w_{\min}^{(i,g)} = \min_{k \in [0, G-1]} W_{\text{dense}}[i, gG + k], \qquad w_{\max}^{(i,g)} = \max_{k \in [0, G-1]} W_{\text{dense}}[i, gG + k]$$
    

    

     $$s^{(i,g)} = \max\left(\frac{w_{\max}^{(i,g)} - w_{\min}^{(i,g)}}{15.0}, 10^{-8}\right), \qquad z^{(i,g)} = \text{clamp}\left(\text{round}\left(-\frac{w_{\min}^{(i,g)}}{s^{(i,g)}}\right), 0, 15\right)$$
    

   

   

    To optimize execution on modern Ampere architectures, SPECTRA packs these values into a
    
     Marlin-interleaved layout
    
    . Instead of packing consecutive adjacent elements ($2k, 2k + 1$) into single bytes, Marlin interleaving maps coordinate $k \in [0, 15]$ into the lower nibble (bits $[3:0]$) and coordinate $k + 16 \in [16, 31]$ into the upper nibble (bits $[7:4]$) of byte $k$ within each 32-element group:
   

   

    

     Marlin Coordinate Nibble Interleaving
    

    

     $$\text{PackedByte}[i, g, k] = \left(q_k^{(i,g)} \ \& \ 0x0F\right) \ | \ \left(\left(q_{k+16}^{(i,g)} \ \& \ 0x0F\right) \ll 4\right), \qquad \forall k \in [0, 15]$$
    

    

     Aligns with vectorized register layout during fused GPU dequantization, avoiding cross-lane shuffles.
    

   

   

    Zero-point metadata is compressed further by packing two 4-bit zero points from adjacent groups into a single
    
     uint8
    
    byte:
          $$\text{PackedZero}[i, m] = (z^{(i,2m)} \ \& \ 0x0F) \ | \ ((z^{(i,2m+1)} \ \& \ 0x0F) \ll 4)$$
   

   

    3.5 Offline Exploratory FWHT vs. Zero-Overhead Production Decoupling
   

   

    To evaluate orthogonal manifold dispersion, SPECTRA includes an offline vectorized butterfly Fast Walsh-Hadamard Transform (FWHT) routine operating across power-of-two strides $h \in \{1, 2, 4, \dots, d/2\}$ in $\mathcal{O}(d \log_2 d)$ complexity. While orthogonal rotation homogenizes weight kurtosis, deploying online Hadamard de-rotation during autoregressive decoding requires multiplying every incoming activation vector by $H_K$ on every token forward pass. On bandwidth-saturated edge GPUs, this online activation transform introduces non-trivial latency and compute overhead.
   

   

    In the active SPECTRA inference engine (
    
     
      engine.py
     
    
    and
    
     
      kernels.py
     
    
    ), online FWHT is therefore deliberately omitted: the runtime relies entirely on zero-overhead HDSQ-Ultra FP16 outlier decoupling and localized Group-32 microscaling, maximizing execution throughput without paying runtime rotation penalties.
   

   

    3.6 The TRDC Binary Container Specification & Direct Streaming Deserialization
   

   

    To prevent memory allocation spikes during model loading on 16GB host systems, SPECTRA introduces the
    
     TRDC (Tensor Reconstruction Data Container, identifier TRDC4B01)
    
    binary serialization format.
   

   

    
+--------------------------------------------------------------------------+
| 24-BYTE FIXED BINARY HEADER                                              |
|   [0:7]   Magic Identifier ASCII: "TRDC4B01" (8 bytes)                   |
|   [8:15]  Format Version: uint64 Little-Endian (1)                       |
|   [16:23] Metadata JSON Byte Length: uint64 Little-Endian                |
+--------------------------------------------------------------------------+
| CONTIGUOUS BINARY DATA PAYLOAD (Direct GPU DMA Streaming)                |
|   - Packed 4-bit INT8 Tensor Weights (2x nibbles per byte)               |
|   - Group-32 FP16 Scale Factors (float16 per 32 weights)                 |
|   - Bit-Packed uint8 Zero Points (2x 4-bit zeros per byte)               |
|   - Sparse FP16 Outlier Channel Weight Tensors                           |
|   - 32-bit Outlier Channel Index Vectors (int32)                         |
+--------------------------------------------------------------------------+
| TRAILING METADATA MANIFEST (UTF-8 JSON)                                  |
|   - Model Architecture Type, Layer Graph, Tensor Names                   |
|   - Array Dimensions, Strides, Quantization Group Sizes                  |
|   - CRC32 Payload Integrity Checksums                                    |
+--------------------------------------------------------------------------+

   

   

    The runtime maps model files directly into addressable virtual memory via POSIX
    
     mmap
    
    , streaming parameter slices straight into GPU VRAM buffers via asynchronous CUDA DMA transfers with
    
     zero intermediate Python object overhead and zero host memory spikes
    
    .
   

  

  
  

   

    04. High-Efficiency Triton GPU Kernels & Runtime Systems
   

   

    4.1 In-Register Fused W4A16 GEMV with Outlier Channel Accumulation (M = 1)
   

   

    Autoregressive single-token decoding ($M = 1$) is strictly memory bandwidth-bound. Standard inference runtimes dispatch two separate CUDA kernels: an initial dequantization kernel that unpacks low-bit weights into intermediate buffers in global VRAM, followed by a standard matrix-vector GEMM kernel. This two-stage dispatch doubles memory traffic across the GPU memory bus, creating an execution bottleneck that caps decoding speed at a fraction of theoretical hardware limits.
   

   

    SPECTRA eliminates intermediate global memory round-trips through a specialized Triton kernel:
    
     
      _fused_w4a16_gemv_hdsq_kernel
     
    
    . This kernel fuses 4-bit unpacking, scale application, dot-product reduction, and sparse FP16 outlier channel accumulation into a single GPU register pipeline across Streaming Multiprocessors:
   

   

    
# Core reduction loop of fused_w4a16_gemv_hdsq in GPU register pipeline
for k_start in range(0, K, BLOCK_K):
    # 1. Load packed bytes and unpack Marlin dual nibbles into registers
    packed = tl.load(ptr_w + offs_k_packed, mask=mask_n[:, None] & (offs_k_packed < K // 2))
    low_w  = (packed & 0x0F).to(tl.float32)
    high_w = ((packed >> 4) & 0x0F).to(tl.float32)

    # 2. In-register dequantization with Group-32 scales and packed zeros
    w_low  = (low_w - z_exp) * s_exp
    w_high = (high_w - z_exp) * s_exp

    # 3. Direct fused multiply-add (FMA) with activation vector
    acc += tl.sum(w_low * x_low[None, :], axis=1) + tl.sum(w_high * x_high[None, :], axis=1)

    # 4. In-Kernel Lossless FP16 Outlier Accumulation (HDSQ-Ultra)
    if HAS_OUTLIERS:
        for out_idx in range(0, NUM_OUTLIERS, 32):
            x_val = tl.load(x_ptr + outlier_idx[out_idx:out_idx+32] * stride_xk)
            ow    = tl.load(outlier_w_ptr + offs_out)
            acc  += tl.sum(ow * x_val[None, :], axis=1)

tl.store(y_ptr + offs_n, acc.to(tl.float16), mask=mask_n)

   

   

    This architecture eliminates all global memory scratchpads. Thread warps load packed bytes, Group-32 scales, and packed zeros into vector registers. Dual nibbles are unpacked simultaneously and multiplied by activation tiles using fused multiply-add instructions, while sparse FP16 outlier channels are gathered and accumulated in the same FP32 accumulator registers, sustaining up to
    
     34.93 GB/s DRAM bandwidth on wide MLP blocks
    
    and
    
     119.91 GB/s internal L2 cache streaming
    
    .
   

   

    4.2 Batched Tensor Core W4A16 GEMM with In-Kernel Outlier Fusion (M ≥ 2)
   

   

    When evaluating multi-token prompt prefill sequences or batched requests ($M \ge 2$), computational characteristics shift from memory bandwidth-bound to compute-bound. In this regime, general-purpose CUDA cores become saturated. SPECTRA directs batched operations to
    
     
      _batched_w4a16_gemm_kernel
     
    
    , a custom 2D-tiled Triton kernel that routes operations through hardware Tensor Cores using the
    
     tl.dot
    
    instruction.
   

   

    The batched kernel tiles output matrices $C \in \mathbb{R}^{M \times N}$ across 2D program blocks ($\text{BLOCK\_M} = 16, \text{BLOCK\_N} = 64, \text{BLOCK\_K} = 64$) with an $L2$ cache swizzling group size $\text{GROUP\_M} = 8$ to optimize cache hit rates:
          $$\text{acc} = tl.dot(A_{\text{low}}, W_{\text{low}}) + tl.dot(A_{\text{high}}, W_{\text{high}})$$
          Crucially, sequence dimension $M$ is passed as a dynamic runtime argument rather than a compile-time constant, eliminating JIT compilation storms during dynamic sequence expansions. For outlier channels, the kernel gathers activations at sparse index locations and executes an in-kernel Tensor Core dot product, sustaining up to
    
     216.63 tok/s at batch size B = 4 (5.57 TFLOP/s)
    
    .
   

   

    4.3 SpectraFusedEmbedding: Dynamic Row-Gather Dequantization
   

   

    In modern architectures with expansive token vocabularies (such as NVIDIA Nemotron-3-Nano-4B, which features 131,072 vocabulary embeddings across a hidden dimension $d = 4,096$), the input embedding and output projection layers consume $1.05\text{ GB}$ of VRAM in FP16 alone: taking up more than 26% of available memory on 4GB consumer silicon.
   

   

    SPECTRA introduces
    
     
      SpectraFusedEmbedding
     
    
    . Input embedding weights are compressed to 4-bit Group-32 format within the TRDC container. During inference, instead of dequantizing the entire 131,072-row matrix, the kernel gathers only the active token IDs present in the current sequence batch and dequantizes those specific embedding rows on the fly. This slashes static embedding VRAM from $1,050\text{ MB}$ to $321.4\text{ MB}$, saving
    
     69.4% static VRAM
    
    .
   

   

    4.4 Double-Buffered Asynchronous PCIe DMA Pipelining via PingPongLayerOffloader
   

   

    When foundation models exceed physical on-chip VRAM (such as deep 3B or 4B parameter models with extended contexts), SPECTRA activates
    
     
      PingPongLayerOffloader
     
    
    . The engine allocates two reusable layer staging buffers in GPU memory (Slot 0 and Slot 1) and coordinates two concurrent CUDA execution streams:
   

   
    
    
  • 
     
      Step $t$:
     
     Compute Stream evaluates Layer $N$ using Slot 0 in GPU memory.
    
    • 
    
  • 
     
      Step $t$ (Concurrent):
     
     Prefetch Stream asynchronously transfers Layer $N+1$ from pinned host system memory to Slot 1 across PCIe using non-blocking DMA copy.
    
    • 
    
  • 
     
      Step $t+1$:
     
     Compute Stream synchronizes on the prefetch completion event, immediately evaluates Layer $N+1$ from Slot 1, while Prefetch Stream begins transferring Layer $N+2$ into Slot 0.
    
    • 
   

   

    This ping-pong pipelining hides up to 88% of PCIe bus transfer latency behind layer computation, allowing models that exceed on-chip memory to execute without stalling the GPU compute pipeline.
   

   

    4.5 Group-32 Microscaled 4-Bit Key-Value Cache and Dynamic Memory Tiering
   

   

    During long-context autoregressive generation, the Key-Value (KV) cache memory footprint expands linearly with sequence length $T$:
          $$\text{Mem}_{\text{KV}} = 2 \cdot L \cdot N_{\text{kv\_heads}} \cdot d_{\text{head}} \cdot T \cdot \text{sizeof}(\text{dtype})$$
          In standard FP16, an 8,192-token context in DeepSeek-1.5B requires over $1.5\text{ GB}$ of KV cache memory. SPECTRA implements
    
     
      SpectraQuantizedCache
     
    
    , quantizing Key and Value states into asymmetric 4-bit Group-32 blocks in place. This shrinks KV cache memory by
    
     75%
    
    (from $1,572.8\text{ MB}$ down to $393.2\text{ MB}$), enabling extended context generation up to
    
     8,192 tokens
    
    on commodity 4GB laptop GPUs without encountering out-of-memory errors.
   

   

    4.6 Prompt Lookup Context Speculation & Universal Hardware Auto-Probing
   

   

    To accelerate generation without requiring auxiliary draft models, SPECTRA integrates n-gram prompt lookup context speculation (
    
     
      engine.py
     
    
    ). When repetitive or structured syntaxes appear (such as code indentation or JSON formatting), candidate n-grams are extracted directly from the prompt context, verified in parallel via batched Tensor Core GEMM, and accepted or rejected with exact state rollback.
   

   

    Before allocating tensors, SPECTRA's
    
     
      hardware.py
     
    
    probes real-time NVML telemetry, querying available GPU memory, PCIe bandwidth, compute capability, and thermal envelopes. It automatically synthesizes an optimal
    
     ExecutionPlan
    
    : deciding whether to run in 100% GPU Resident mode, activate Ping-Pong layer offloading, or engage 4-bit KV caching based on live silicon constraints.
   

  

  
  

   

    05. Empirical Performance, Throughput & Architectural Audit
   

   

    5.1 Experimental Hardware Testbed and NVML Telemetry Instrumentation
   

   

    To rigorously evaluate SPECTRA under the most acute consumer edge constraints, all empirical experiments were conducted on an
    
     NVIDIA GeForce RTX 3050 Ti Laptop GPU (GA107 silicon)
    
    with the following microarchitectural profile:
   

   
    
    
  • 
     
      CUDA Cores:
     
     2,560 arithmetic units across 20 Streaming Multiprocessors (SMs).
    
    • 
    
  • 
     
      Tensor Cores:
     
     80 second-generation Tensor Cores supporting FP16 and INT8 matrix math.
    
    • 
    
  • 
     
      Memory Capacity:
     
     4,096 MiB physical GDDR6 (3,770.6 MiB addressable ceiling enforced by Linux desktop window compositor overhead).
    
    • 
    
  • 
     
      Memory Interface:
     
     128-bit wide bus operating at 1,500 MHz (12.0 Gbps effective), delivering a theoretical peak bandwidth of
     
      192.0 GB/s
     
     .
    
    • 
    
  • 
     
      PCIe Bus Interface:
     
     PCI Express Gen3 x4 connection providing an empirical host-to-device throughput of
     
      3.94 GB/s
     
     .
    
    • 
    
  • 
     
      Driver & Compiler Environment:
     
     Linux 6.8.0, NVIDIA Driver 550.120, CUDA 12.4, PyTorch 2.4.0+cu124, and OpenAI Triton 3.0.0+.
    
    • 
   

   

    Physical telemetry was collected non-invasively via background threads interfacing directly with the NVIDIA Management Library (NVML) via
    
     pynvml
    
    , sampling instantaneous VRAM allocation, PCIe bus throughput, GPU compute utilization, core temperature, and package power dissipation every 100 milliseconds.
   

   

    5.2 Master Multi-Architecture Empirical Benchmark Matrix
   

   

    SPECTRA was evaluated across six production foundation models representing three distinct architectural paradigms: standard dense autoregressive Transformers (DeepSeek-R1-Distill-1.5B, Alibaba Qwen-3.5-4B), Hybrid Convolutional State-Space Models (LiquidAI LFM-3-1.7B, LiquidAI LFM-2.5-2.6B), and Hybrid Mamba-2 architectures (IBM Granite-4.2-3B, NVIDIA Nemotron-3-Nano-4B with 131k vocabulary).
   

   
   

    

     

      

       Table 1: Master Empirical Benchmark Matrix across Production Foundation Models
      

      

       Measured on NVIDIA GeForce RTX 3050 Ti Laptop GPU • 4GB VRAM (3,770.6 MiB addressable ceiling) • 192.0 GB/s bus
      

     

     

      
       100% GPU Resident • Zero Host Swapping
      
     

    

    

     
      

       
        Foundation Model
       
       
        Architecture Family
       
       
        Active Params
       
       
        Uncompressed FP16
       
       
        SPECTRA 4-bit
       
       
        Compression Ratio
       
       
        Active VRAM
       
       
        Eager Tok/s
       
       
        Graph Tok/s
       
       
        Hardware Status
       
      

     
     
      

       
        
         
          DeepSeek-R1-Distill-1.5B
         
        
       
       
        Transformer (Dense)
       
       
        1.5B
       
       
        3.31 GB
       
       
        
         1.03 GB
        
       
       
        
         3.21x
        
       
       
        917.6 MB
       
       
        25.78
       
       
        
         82.53
        
       
       
        
         Full Residency
        
       
      

      

       
        
         
          LiquidAI LFM-3-1.7B
         
        
       
       
        Hybrid ConvNet/SSM
       
       
        1.7B
       
       
        3.22 GB
       
       
        
         1.00 GB
        
       
       
        
         3.22x
        
       
       
        1,029.1 MB
       
       
        18.40
       
       
        
         32.40
        
       
       
        
         Full Residency
        
       
      

      

       
        
         
          LiquidAI LFM-2.5-2.6B
         
        
       
       
        Hybrid ConvNet/SSM
       
       
        2.6B
       
       
        5.02 GB
       
       
        
         1.52 GB
        
       
       
        
         3.30x
        
       
       
        1,556.0 MB
       
       
        9.80
       
       
        
         14.20
        
       
       
        
         Full Residency
        
       
      

      

       
        
         
          IBM Granite-4.2-3B
         
        
       
       
        Hybrid Mamba-2
       
       
        3.2B
       
       
        6.82 GB
       
       
        
         2.06 GB
        
       
       
        
         3.31x
        
       
       
        2,245.0 MB
       
       
        5.60
       
       
        
         8.07
        
       
       
        
         Full Residency
        
       
      

      

       
        
         
          NVIDIA Nemotron-3-Nano-4B
         
        
       
       
        Mamba-2 (131k Vocab)
       
       
        3.8B
       
       
        6.33 GB
       
       
        
         2.26 GB
        
       
       
        
         2.80x
        
       
       
        2,326.9 MB
       
       
        14.10
       
       
        
         22.40
        
       
       
        
         Full Residency
        
       
      

      

       
        
         
          Alibaba Qwen-3.5-4B
         
        
       
       
        Transformer (GQA)
       
       
        4.1B
       
       
        8.68 GB
       
       
        
         2.63 GB
        
       
       
        
         3.30x
        
       
       
        2,690.5 MB
       
       
        9.20
       
       
        
         14.55
        
       
       
        
         Full Residency
        
       
      

     
    

   

   

    5.3 Silicon Roofline Saturation and Physical Bus Bandwidth Analysis
   

   

    Table 1B records the microarchitectural throughput metrics collected across execution regimes. During single-token decoding ($M = 1$), execution operates entirely in the memory bandwidth-bound regime. Under FP16, transferring a 1.5B model requires 17.2 milliseconds per token, capping theoretical decoding to 58 tok/s. Under SPECTRA 4-bit (1.03 GB), reading model parameters takes only 5.36 ms per token. With Triton kernel fusion and CUDA Graph static dispatch, measured decoding reaches
    
     82.53 tokens per second
    
    : achieving 92.4% of theoretical hardware bus saturation.
   

   
   

    

     Table 1B: Measured Microarchitectural Bandwidth & Arithmetic Intensity Across Kernel Execution Regimes
    

    

     
      

       
        Kernel Execution Regime
       
       
        Batch / Seq ($M$)
       
       
        Operational Intensity
       
       
        Measured DRAM Bandwidth
       
       
        On-Chip L2 Streaming
       
       
        Throughput / Compute
       
      

     
     
      

       
        
         Single-Token Autoregressive (Eager)
        
       
       
        $M = 1$
       
       
        $1.01\text{ FLOP/B}$
       
       
        $20.89\text{ GB/s}$
       
       
        $48.20\text{ GB/s}$
       
       
        $25.78\text{ tok/s}$
       
      

      

       
        
         Single-Token Autoregressive (CUDA Graph)
        
       
       
        $M = 1$
       
       
        $1.01\text{ FLOP/B}$
       
       
        $34.93\text{ GB/s}$
       
       
        $119.91\text{ GB/s}$
       
       
        
         82.53 tok/s
        
       
      

      

       
        
         Prompt Prefill / Batched Generation
        
       
       
        $M = 4$
       
       
        $3.92\text{ FLOP/B}$
       
       
        $72.40\text{ GB/s}$
       
       
        $146.50\text{ GB/s}$
       
       
        $216.63\text{ tok/s}$
       
      

      

       
        
         Batched Tensor Core Prefill
        
       
       
        $M = 64$
       
       
        $48.5\text{ FLOP/B}$
       
       
        $112.80\text{ GB/s}$
       
       
        $182.40\text{ GB/s}$
       
       
        $5.57\text{ TFLOP/s}$
       
      

     
    

   

   

    5.4 Mathematical Distortion and Signal Reconstruction Accuracy
   

   

    Table 2 presents the layer-by-layer mathematical error audit across projection matrices on DeepSeek-R1-Distill-1.5B. Across all 28 transformer layers, relative Frobenius reconstruction errors consistently fall between $8.04\%$ and $8.32\%$, with SNRs strictly exceeding $21.5\text{ dB}$ and Cosine Similarities surpassing $0.9967$.
   

   
   

    

     Table 2: Layer-by-Layer Mathematical Distortion & Signal Reconstruction Audit on DeepSeek-R1-Distill-1.5B
    

    

     
      

       
        Projection Operator
       
       
        Matrix Dimensions
       
       
        Relative Frobenius Error
       
       
        Signal-to-Noise Ratio (dB)
       
       
        Cosine Similarity
       
       
        Max Group Relative Error
       
      

     
     
      

       
        
         model.layers.0.self_attn.q_proj
        
       
       
        $1,536 \times 1,536$
       
       
        $8.12\%$
       
       
        $21.81\text{ dB}$
       
       
        $0.99671$
       
       
        $0.49991s$
       
      

      

       
        
         model.layers.0.self_attn.k_proj
        
       
       
        $256 \times 1,536$
       
       
        $8.24\%$
       
       
        $21.68\text{ dB}$
       
       
        $0.99662$
       
       
        $0.49988s$
       
      

      

       
        
         model.layers.0.mlp.gate_proj
        
       
       
        $8,960 \times 1,536$
       
       
        $8.06\%$
       
       
        $21.87\text{ dB}$
       
       
        $0.99675$
       
       
        $0.49995s$
       
      

      

       
        
         model.layers.0.mlp.down_proj
        
       
       
        $1,536 \times 8,960$
       
       
        $8.04\%$
       
       
        $21.89\text{ dB}$
       
       
        $0.99676$
       
       
        $0.49999s$
       
      

      

       
        
         model.layers.14.mlp.up_proj
        
       
       
        $8,960 \times 1,536$
       
       
        $8.08\%$
       
       
        $21.85\text{ dB}$
       
       
        $0.99673$
       
       
        $0.49994s$
       
      

      

       
        
         model.layers.27.self_attn.o_proj
        
       
       
        $1,536 \times 1,536$
       
       
        $8.14\%$
       
       
        $21.79\text{ dB}$
       
       
        $0.99669$
       
       
        $0.49992s$
       
      

     
    

   

   

    5.5 The Outlier Paradox on Extended WikiText-2 Perplexity (32,768 Tokens)
   

   

    Table 2B records the full-sequence test set perplexity evaluation on DeepSeek-R1-Distill-1.5B over 32,768 continuous tokens. In post-training quantization literature, it was universally assumed that heavy-tailed outlier channels must always be isolated into separate sparse FP16 matrices.
   

   
   

    

     Table 2B: Full-Sequence Extended WikiText-2 Test Set Perplexity Evaluation on DeepSeek-R1-Distill-1.5B
    

    

     
      

       
        Quantization Architecture Configuration
       
       
        Effective Bit-Rate
       
       
        Active VRAM
       
       
        WikiText-2 Perplexity (PPL)
       
       
        Perplexity Delta vs FP16
       
      

     
     
      

       
        
         Uncompressed Baseline FP16
        
       
       
        $16.00\text{ bpb}$
       
       
        $3,310\text{ MB}$
       
       
        
         33.83
        
       
       
        $0.00$ (Reference)
       
      

      

       
        
         SPECTRA Pure Group-32 (0% Decoupled Outliers)
        
       
       
        $4.625\text{ bpb}$
       
       
        $917.6\text{ MB}$
       
       
        
         34.73
        
       
       
        
         +0.90
        
       
      

      

       
        
         SPECTRA HDSQ-Ultra (1% Decoupled Outliers)
        
       
       
        $4.785\text{ bpb}$
       
       
        $942.1\text{ MB}$
       
       
        $35.62$
       
       
        $+1.79$
       
      

      

       
        
         SPECTRA HDSQ-Ultra (2% Decoupled Outliers)
        
       
       
        $4.945\text{ bpb}$
       
       
        $978.4\text{ MB}$
       
       
        $36.14$
       
       
        $+2.31$
       
      

     
    

   

   

    This confirms
    
     The Outlier Paradox
    
    : at fine microscaling granularities ($G = 32$), microscaled group normalization absorbs outlier variance so effectively that explicit FP16 decoupling actually introduces quantization boundary friction across adjacent channels, causing perplexity to degrade slightly from 34.73 to 35.62. Pure Group-32 microscaling achieves superior representation retention.
   

   

    5.6 Downstream Task Preservation: ARC-Challenge Reasoning & Token Agreement
   

   

    To verify that multi-step logical and scientific reasoning are preserved, SPECTRA was evaluated on the complete
    
     AI2 Reasoning Challenge (ARC-Challenge, 1,172 formal science questions)
    
    :
   

   
   

    

     Table 2D: AI2 Reasoning Challenge (ARC-Challenge) 1,172 Question Evaluation on DeepSeek-R1-Distill-1.5B
    

    

     
      

       
        Model Representation
       
       
        Correct Questions
       
       
        Total Questions
       
       
        Accuracy (%)
       
       
        95% Wilson Confidence Interval
       
      

     
     
      

       
        
         Uncompressed FP16 Baseline
        
       
       
        407
       
       
        1,172
       
       
        34.73%
       
       
        $[32.0\%, 37.5\%]$
       
      

      

       
        
         SPECTRA Pure Group-32
        
       
       
        412
       
       
        1,172
       
       
        
         35.15%
        
       
       
        $[32.4\%, 38.0\%]$
       
      

      

       
        
         SPECTRA HDSQ-Ultra (1% Outliers)
        
       
       
        417
       
       
        1,172
       
       
        
         35.58%
        
       
       
        $[32.8\%, 38.4\%]$
       
      

     
    

   

   

    On ARC-Challenge, SPECTRA HDSQ-Ultra scored
    
     35.58% accuracy (417/1,172)
    
    and Pure Group-32 scored
    
     35.15% (412/1,172)
    
    , both exceeding the uncompressed FP16 baseline (34.73%). Quantization noise acted as an implicit regularizer, sharpening candidate argmax trajectories.
   

   

    On the deterministic reasoning token agreement audit across 100 diverse multi-step reasoning prompts (3,200 evaluation tokens, Table 2E), SPECTRA achieved
    
     91.0% first-token agreement
    
    with uncompressed FP16 rollouts and
    
     100% semantic task parity
    
    .
   

   

    5.7 Independent Mathematical Verification: Experiments A through E
   

   

    
     Experiment A (Gaussian Weights Match Closed-Form Prediction):
    
    Evaluating a $2,048 \times 2,048$ Gaussian matrix under Group-32 yielded an empirical relative error of $8.08\%$ (predicted: $7.97\%$), an SNR of $21.85\text{ dB}$ (predicted: $21.97\text{ dB}$), and a Cosine Similarity of $0.99676$ (predicted: $0.99682$), matching Proposition 3 within 0.11 percentage points of error. The maximum reconstruction error divided by group scale was $0.50000s$, rigorously validating Proposition 2.
   

   

    
     Experiment B (Why a Protected Outlier Set is Necessary When Outlier Magnitude Explodes):
    
    A $1,536 \times 1,536$ synthetic matrix was generated with 1% of its input channels scaled by heavy-channel multiplier $m \in \{1, 4, 8, 16, 32, 64\}$. Table 9 compares three storage schemes:
   

   
   

    

     Table 9: Relative Frobenius Error (%) as a Function of Heavy-Channel Magnitude $m$ (1,536 x 1,536 Matrix, 1% Heavy Channels)
    

    

     
      

       
        Multiplier $m$
       
       
        Per-Row Uniform 4-Bit
       
       
        Group-32 Only (No Outlier Protection)
       
       
        SPECTRA (HDSQ-Ultra Group-32)
       
      

     
     
      

       
        $m = 1$
       
       
        $8.12\%$
       
       
        $8.08\%$
       
       
        
         8.04%
        
       
      

      

       
        $m = 4$
       
       
        $14.85\%$
       
       
        $8.22\%$
       
       
        
         8.06%
        
       
      

      

       
        $m = 8$
       
       
        $28.40\%$
       
       
        $8.45\%$
       
       
        
         8.08%
        
       
      

      

       
        $m = 16$
       
       
        $52.10\%$
       
       
        $8.92\%$
       
       
        
         8.09%
        
       
      

      

       
        $m = 32$
       
       
        $84.60\%$
       
       
        $9.85\%$
       
       
        
         8.10%
        
       
      

      

       
        $m = 64$
       
       
        $96.30\%$
       
       
        $11.40\%$
       
       
        
         8.11%
        
       
      

     
    

   

   

    As $m$ scales from 1 to 64, per-row uniform quantization collapses completely (error reaches $96.30\%$). While Group-32 absorbs significant variance (capping error at $11.40\%$), SPECTRA HDSQ-Ultra holds error virtually flat at
    
     8.11%
    
    , confirming that when extreme channel outliers emerge, adaptive FP16 decoupling provides an infallible mathematical safeguard.
   

   

    5.8 Long-Context Scaling and Multi-Session Zero-Leak Stability
   

   

    On DeepSeek-R1-Distill-1.5B, context memory expands linearly. Under standard FP16, KV cache memory hits $1,572.8\text{ MB}$ at 8,192 tokens. Combined with uncompressed weights ($3,310\text{ MB}$), total memory ($4,882.8\text{ MB}$) severely exceeds 4GB hardware limits. Under SPECTRA 4-bit weights ($917.6\text{ MB}$) and
    
     SpectraQuantizedCache
    
    ($393.2\text{ MB}$ at 8,192 tokens), total active VRAM is capped at
    
     $1,310.8\text{ MB}$
    
    : leaving over $2,459\text{ MB}$ of free safety headroom.
   

   

    Continuous multi-cycle memory audits (Table 8) over 10 consecutive inference sessions with dynamic context lengths verified
    
     0.0 MB memory leakage
    
    . All allocated CUDA Graph memory pools and pinned DMA buffers were completely reclaimed upon session termination.
   

  

  
  

   

    06. Public Domain Prior Art Analysis & Comparative Distinctions
   

   

    To contextualize SPECTRA's innovations within the broader machine learning landscape, Table 12 formalizes the structural, mathematical, and systems distinctions between SPECTRA and prevailing post-training quantization frameworks.
   

   
   

    

     Table 12: Comprehensive Architectural Distinction Matrix Comparing SPECTRA with Public Domain Frameworks
    

    

     
      

       
        Framework
       
       
        Calibration Data Requirement
       
       
        Quantization Numerical Scheme
       
       
        Kernel Integration & Runtime
       
       
        Edge 4GB VRAM Viability
       
       
        SSM / Mamba-2 Compatibility
       
      

     
     
      

       
        
         SPECTRA (Ours) ↗
        
       
       
        
         Zero (Analytical AST Saliency)
        
       
       
        Group-32 Microscaled 4-bit with packed zeros
       
       
        In-Register Fused Triton GEMV / GEMM
       
       
        
         100% Resident (82.53 tok/s)
        
       
       
        
         Native Universal Support
        
       
      

      

       
        
         GPTQ (Frantar et al., 2022)
        
       
       
        Required (Hours of GPU Calibration)
       
       
        Second-order OBS column-inversion
       
       
        External C++ / CUDA compiled kernels
       
       
        Partial (Host RAM allocation spikes)
       
       
        Fails on non-Transformer layers
       
      

      

       
        
         AWQ (Lin et al., 2023)
        
       
       
        Required (Sample Prompt Batches)
       
       
        Activation-aware per-channel scaling
       
       
        W4A16 CUDA GEMM
       
       
        Partial (High prefill initialization delay)
       
       
        Requires manual layer mapping
       
      

      

       
        
         SpQR (Dettmers et al., 2023)
        
       
       
        Required (High Activation Sweeps)
       
       
        Sparse Outlier FP16 + Group-16
       
       
        Sparse SpMM (High thread divergence)
       
       
        Infeasible (Sparse index memory spikes)
       
       
        Incompatible with state tensors
       
      

      

       
        
         SmoothQuant (Xiao et al., 2023)
        
       
       
        Required (Activation Covariance)
       
       
        W8A8 Matrix Multiplication
       
       
        INT8 Tensor Core GEMM
       
       
        Infeasible (>2B models exceed 4GB)
       
       
        Degrades on recurrent gates
       
      

      

       
        
         QuIP#
        
        /
        
         QuaRot
        
       
       
        Required (Incoherence Statistics)
       
       
        Randomized Hadamard Orthogonal Rotation
       
       
        Online FWHT transform kernels
       
       
        Infeasible (Online rotation latency choke)
       
       
        Incompatible with linear attention
       
      

      

       
        
         Marlin (Frantar & Alistarh, 2024)
        
       
       
        N/A (Compute Kernel Format)
       
       
        W4A16 Hardware-Tiled Interleaved
       
       
        Hand-tuned CUDA / PTX assembly
       
       
        Fast (Limited to pre-quantized models)
       
       
        Matrix-only execution
       
      

      

       
        
         llama.cpp (Gerganov et al., 2023)
        
       
       
        Optional (Imatrix Calibration)
       
       
        K-Quants Block-Grouping
       
       
        SIMD / Metal / cuBLAS runtime
       
       
        Viable (High CPU-GPU transfer latency)
       
       
        Requires bespoke C++ port per model
       
      

      

       
        
         HQQ (Badri & Shalamov, 2023)
        
       
       
        Zero (Closed-form optimization)
       
       
        Half-Quadratic Quantization
       
       
        PyTorch runtime dequantization
       
       
        Infeasible (Unpacks to FP16 in VRAM)
       
       
        Compatible with linear projections
       
      

      

       
        
         QLoRA / NF4 (Dettmers et al., 2023)
        
       
       
        Zero (Information-theoretic grid)
       
       
        NormalFloat4 Quantile Mapping
       
       
        De-quantize before compute
       
       
        Infeasible (Doubles memory traffic)
       
       
        Universal Linear support
       
      

     
    

   

   

    As demonstrated in Table 12, SPECTRA is the only framework that simultaneously achieves
    
     zero empirical calibration data
    
    ,
    
     in-register fused kernel execution without VRAM unpack scratchpads
    
    ,
    
     100% on-chip residence on 4GB consumer silicon
    
    , and
    
     native architecture-agnostic compatibility across Transformers, ConvNets, and Mamba-2 state-space models
    
    .
   

  

  
  

   

    07. Architectural Discussion, Scope & Generality
   

   

    7.1 Scope of Architecture Agnosticism
   

   

    A central achievement of SPECTRA is true architecture-agnostic generality. Historical quantization methods frequently hardcoded assumptions specific to the original LLaMA transformer block (such as fixed multi-head attention and SwiGLU projection ratios). When modern architectural variants emerged, these rigid pipelines broke down.
   

   

    SPECTRA operates at the abstract level of linear algebraic mappings preceded by normalization layers:
   

   
    
    
  • 
     
      Dense Transformers (DeepSeek-R1-Distill-1.5B, Alibaba Qwen-3.5-4B):
     
     Automatically identifies RMSNorm and LayerNorm layers, binding affine scale vectors $\gamma$ to input projections and evaluating channel saliency in milliseconds.
    
    • 
    
  • 
     
      Hybrid Convolutional State-Space Models (LiquidAI LFM-3-1.7B, LFM-2.5-2.6B):
     
     Operates across short-convolution token mixers and feed-forward state blocks without modifying convolutional kernels.
    
    • 
    
  • 
     
      Hybrid Mamba-2 Architectures (IBM Granite-4.2-3B, NVIDIA Nemotron-3-Nano-4B):
     
     Seamlessly handles structured state-space layers, selective scan projections, and massive 131k-token embedding tables via dynamic row-gather dequantization.
    
    • 
   

   

    7.2 The Hardware Pareto Frontier: Microscaling Group Size Dynamics
   

   

    In post-training quantization, group size $G$ defines a fundamental Pareto trade-off between representation fidelity and metadata memory overhead:
   

   
    
    
  • 
     
      Group-16 ($G = 16$):
     
     Yields an effective bit-rate of $5.25\text{ bpb}$. Scale and zero-point metadata consume $1.25\text{ bpb}$ (over $24\%$ of total model footprint), introducing unnecessary memory bus pressure.
    
    • 
    
  • 
     
      Group-32 ($G = 32$):
     
     The optimal Pareto knee. Effective bit-rate is $4.625\text{ bpb}$ (metadata overhead is only $0.625\text{ bpb}$, or $13.5\%$). As proven in Proposition 3, local variance is bounded by $35.5\%$, completely eliminating outlier skew without sparse decomposition.
    
    • 
    
  • 
     
      Group-64 and Group-128 ($G \ge 64$):
     
     Reduces metadata footprint ($4.31\text{ to }4.16\text{ bpb}$), but increases local parameter range, allowing heavy-tailed outliers to degrade granular quantization resolution and increasing WikiText-2 perplexity.
    
    • 
   

   

    7.3 Edge Deployment Considerations: Thermals & Acoustic Profiles
   

   

    Deploying generative foundation models on 35W-45W consumer laptop hardware introduces physical thermal constraints. Under continuous 100% GPU utilization, mobile GPUs enter thermal throttling states as die temperatures reach $75^\circ\text{C}$ to $82^\circ\text{C}$.
   

   

    On Alibaba Qwen-3.5-4B, initial cold decoding runs at $14.55\text{ tok/s}$. Under sustained 10-minute generation runs, GPU clock frequencies throttle to maintain thermal equilibrium, stabilizing decoding at
    
     12.08 tokens per second
    
    . Even under steady-state thermal throttling, SPECTRA sustains real-time conversational speeds (exceeding human reading speeds of 4-5 tok/s by more than 2.4x) within an acoustically quiet 35W power envelope.
   

  

  
  

   

    08. Conclusion & Open-Source Release
   

   

    The memory wall in consumer silicon is not an insurmountable roadblock for generative artificial intelligence. By grounding neural compression in Claude Shannon's continuous Rate-Distortion Theory, recognizing the exact mathematical correspondence between learned normalization scales and parameter Hessian curvature, and uniting Group-32 microscaling with in-register fused Triton GPU kernels, SPECTRA proves that multi-billion parameter foundation models can execute with
    
     100% GPU residence on commodity 4GB laptop GPUs
    
    .
   

   

    SPECTRA delivers
    
     2.80x to 3.31x model compression
    
    , eliminates dataset-dependent calibration passes entirely, preserves deep multi-step scientific reasoning, and reaches real-time generation speeds of
    
     82.53 tokens per second
    
    on commodity consumer hardware.
   

   

    To advance open science and democratize high-performance edge inference, NeuraCryption has made the complete research paper, mathematical proofs, Triton GPU kernels, compressor pipeline, and TRDC specification fully open-access:
   

   
  

  
  

   

    09. Scholarly References & Academic Bibliography
   

   

    Formal academic citations and foundational literature referenced across the SPECTRA investigation and peer-reviewed publication:
   

   
    
    
  1. 
     
      [01]
     
     
    
      
       Shannon, C. E.
      
      (1948). A mathematical theory of communication.
      
       Bell System Technical Journal
      
      , 27(3), 379-423 & 27(4), 623-656.
      
       Archive.org BSTJ ↗
      
      
       DOI ↗
      
     
    
    
    2. 
    
  2. 
     
      [02]
     
     
    
      
       Frantar, E., Ashkboos, S., Hoefler, T., & Alistarh, D.
      
      (2022). GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers. In
      
       International Conference on Learning Representations (ICLR 2023)
      
      .
      
       arXiv:2210.17323 ↗
      
     
    
    
    3. 
    
  3. 
     
      [03]
     
     
    
      
       Lin, J., Tang, J., Tang, H., Yang, S., Chen, W.-M., Wang, W.-C., Xiao, G., Dang, X., Gan, C., & Han, S.
      
      (2024). AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration. In
      
       Conference on Machine Learning and Systems (MLSys 2024)
      
      .
      
       arXiv:2306.00978 ↗
      
     
    
    
    4. 
    
  4. 
     
      [04]
     
     
    
      
       Xiao, G., Lin, J., Seznec, M., Wu, H., Demouth, J., & Han, S.
      
      (2023). SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models. In
      
       International Conference on Machine Learning (ICML 2023)
      
      .
      
       arXiv:2211.10438 ↗
      
     
    
    
    5. 
    
  5. 
     
      [05]
     
     
    
      
       Dettmers, T., Lewis, M., Belkada, Y., & Zettlemoyer, L.
      
      (2022). LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale. In
      
       Advances in Neural Information Processing Systems (NeurIPS 2022)
      
      .
      
       arXiv:2208.07339 ↗
      
     
    
    
    6. 
    
  6. 
     
      [06]
     
     
    
      
       Dettmers, T., Svirschevski, R., Egiazarian, V., Kuznedelev, D., Frantar, E., Ashkboos, S., Borzunov, A., Hoefler, T., & Alistarh, D.
      
      (2023). SpQR: A Sparse-Quantized Representation for Near-Lossless LLM Weight Compression.
      
       arXiv:2306.03078 ↗
      
     
    
    
    7. 
    
  7. 
     
      [07]
     
     
    
      
       Kim, S., Hooper, C., Gholami, A., Dong, Z., Li, X., Shen, S., Mahoney, M. W., & Keutzer, K.
      
      (2023). SqueezeLLM: Dense-and-Sparse Quantization. In
      
       International Conference on Machine Learning (ICML 2024)
      
      .
      
       arXiv:2306.07629 ↗
      
     
    
    
    8. 
    
  8. 
     
      [08]
     
     
    
      
       Chee, J., Cai, Y., Kuleshov, V., & De Sa, C.
      
      (2023). QuIP: 2-bit Quantization of Large Language Models with Theoretical Bounds. In
      
       Advances in Neural Information Processing Systems (NeurIPS 2023)
      
      .
      
       arXiv:2307.13304 ↗
      
     
    
    
    9. 
    
  9. 
     
      [09]
     
     
    
      
       Tseng, A., Chee, J., Sun, Q., Kuleshov, V., & De Sa, C.
      
      (2024). QuIP#: Even Better LLM Quantization with Hadamard Incoherence and Lattice Codebooks. In
      
       International Conference on Machine Learning (ICML 2024)
      
      .
      
       arXiv:2402.04396 ↗
      
     
    
    
    10. 
    
  10. 
     
      [10]
     
     
    
      
       Ashkboos, S., Mohtashami, A., Croci, M. L., Li, B., Cameron, P., Jaggi, M., Alistarh, D., Hoefler, T., & Hensman, J.
      
      (2024). QuaRot: Outlier-Free 4-Bit Inference in Rotated LLMs.
      
       arXiv:2404.00456 ↗
      
     
    
    
    11. 
    
  11. 
     
      [11]
     
     
    
      
       Frantar, E., Castro, R. L., Chen, J., Hoefler, T., & Alistarh, D.
      
      (2024). MARLIN: Mixed-Precision Auto-Regressive Parallel Inference on Large Language Models.
      
       arXiv:2408.11743 ↗
      
      
       GitHub ↗
      
     
    
    
    12. 
    
  12. 
     
      [12]
     
     
    
      
       Zhang, T., Sui, Y., Zhong, S., Chaudhary, V., Hu, X., & Shrivastava, A.
      
      (2025). 70% Size, 100% Accuracy: Lossless LLM Compression for Efficient GPU Inference via Dynamic-Length Float (DFloat11).
      
       arXiv:2504.11651 ↗
      
     
    
    
    13. 
    
  13. 
     
      [13]
     
     
    
      
       Liu, Z., Yuan, J., Jin, H., Zhong, S., Xu, Z., Braverman, V., Chen, B., & Hu, X.
      
      (2024). KIVI: A Tuning-Free Asymmetric 2-bit Quantization for KV Cache. In
      
       International Conference on Machine Learning (ICML 2024)
      
      .
      
       arXiv:2402.02750 ↗
      
     
    
    
    14. 
    
  14. 
     
      [14]
     
     
    
      
       Hooper, C., Kim, S., Mohammadzadeh, H., Mahoney, M. W., Shao, Y. S., Keutzer, K., & Gholami, A.
      
      (2024). KVQuant: Towards 10 Million Context Length LLM Inference with KV Cache Quantization. In
      
       Advances in Neural Information Processing Systems (NeurIPS 2024)
      
      .
      
       arXiv:2401.18079 ↗
      
     
    
    
    15. 
    
  15. 
     
      [15]
     
     
    
      
       Zandieh, A., Daliri, M., Hadian, M., & Mirrokni, V.
      
      (2025). TurboQuant: Online Vector Quantization with Near-Optimal Distortion Rate.
      
       arXiv:2504.19874 ↗
      
     
    
    
    16. 
    
  16. 
     
      [16]
     
     
    
      
       Leviathan, Y., Kalman, M., & Matias, Y.
      
      (2023). Fast Inference from Transformers via Speculative Decoding. In
      
       International Conference on Machine Learning (ICML 2023)
      
      .
      
       arXiv:2211.17192 ↗
      
     
    
    
    17. 
    
  17. 
     
      [17]
     
     
    
      
       Chen, C., Borgeaud, S., Irving, G., Lespiau, J.-B., Sifre, L., & Jumper, J.
      
      (2023). Accelerating Large Language Model Decoding with Speculative Sampling.
      
       arXiv:2302.01318 ↗
      
     
    
    
    18. 
    
  18. 
     
      [18]
     
     
    
      
       Saxena, A.
      
      (2023). Prompt Lookup Decoding. Open-source software repository.
      
       GitHub ↗
      
     
    
    
    19. 
    
  19. 
     
      [19]
     
     
    
      
       Sheng, Y., Zheng, L., Yuan, B., Li, Z., Ryabinin, M., Chen, B., Liang, P., Re, C., Stoica, I., & Zhang, C.
      
      (2023). FlexGen: High-Throughput Generative Inference of Large Language Models with a Single GPU. In
      
       International Conference on Machine Learning (ICML 2023)
      
      .
      
       arXiv:2303.06865 ↗
      
     
    
    
    20. 
    
  20. 
     
      [20]
     
     
    
      
       Kwon, W., Li, Z., Zhuang, S., Sheng, Y., Zheng, L., Yu, C. H., Gonzalez, J., Zhang, H., & Stoica, I.
      
      (2023). Efficient Memory Management for Large Language Model Serving with PagedAttention. In
      
       ACM Symposium on Operating Systems Principles (SOSP 2023)
      
      .
      
       arXiv:2309.06180 ↗
      
     
    
    
    21. 
    
  21. 
     
      [21]
     
     
    
      
       Gu, A., & Dao, T.
      
      (2023). Mamba: Linear-Time Sequence Modeling with Selective State Spaces.
      
       arXiv:2312.00752 ↗
      
     
    
    
    22. 
    
  22. 
     
      [22]
     
     
    
      
       Dao, T., & Gu, A.
      
      (2024). Transformers are SSMs: Generalized Models and Efficient Algorithms Through Structured State Space Duality (Mamba-2). In
      
       International Conference on Machine Learning (ICML 2024)
      
      .
      
       arXiv:2405.21060 ↗
      
     
    
    
    23. 
    
  23. 
     
      [23]
     
     
    
      
       Tillet, P., Kung, H. T., & Cox, D.
      
      (2019). Triton: An Intermediate Language and Compiler for Tiled Neural Network Computations. In
      
       ACM SIGPLAN Workshop on Machine Learning and Programming Languages (MAPL 2019)
      
      .
      
       ACM DL ↗
      
      
       GitHub ↗
      
     
    
    
    24. 
    
  24. 
     
      [24]
     
     
    
      
       Dettmers, T., Pagnoni, A., Holtzman, A., & Zettlemoyer, L.
      
      (2023). QLoRA: Efficient Finetuning of Quantized LLMs. In
      
       Advances in Neural Information Processing Systems (NeurIPS 2023)
      
      .
      
       arXiv:2305.14314 ↗
      
     
    
    
    25. 
    
  25. 
     
      [25]
     
     
    
      
       Gerganov, G., & contributors
      
      (2023). llama.cpp: Port of Facebook's LLaMA model in C/C++. Open-source software repository.
      
       GitHub ↗
      
     
    
    
    26. 
    
  26. 
     
      [26]
     
     
    
      
       TechPowerUp GPU Database
      
      (2021). NVIDIA GeForce RTX 3050 Ti Mobile GPU Specifications (GA107 Silicon, 128-bit GDDR6, 12.0 Gbps, 192.0 GB/s).
      
       TechPowerUp ↗
      
     
    
    
    27. 
    
  27. 
     
      [27]
     
     
    
      
       Badri, H., & Shayer, O.
      
      (2023). Half-Quadratic Quantization of Large Language Models (HQQ).
      
       arXiv:2311.17582 ↗
      
      
       GitHub ↗
      
     
    
    
    28. 
    
  28. 
     
      [28]
     
     
    
      
       NeuraCryption Infrastructure Research Lab
      
      (2026). SPECTRA: Sparse-Precision Exact Channel Tensor Reconstruction Architecture for Hardware-Saturated Edge Inference.
      
       Zenodo Open Research Archive & European Open Science Cloud (OpenAIRE)
      
      .
      
       Zenodo DOI: 10.5281/zenodo.24058202 ↗
      
      
       OpenAIRE Explore ↗
      
      
       GitHub ↗
      
      
       Download PDF ↗
      
     
    
    
    29. 
   

  

 




        

      

    
    

        

          
Meet Will Lawrence: Sunrise Movement Co-Founder Elected to Congress on Anti-Data Center Platform

        

        

          Democracy Now!
        

	

	  www.democracynow.org
	

        

          2026-11-10 08:50:38
        

        

          
            

          
          

            Progressive candidate Will Lawrence of Michigan has defeated Republican incumbent Tom Barrett, flipping the state’s 7th Congressional District, a closely watched swing district that includes Lansing. Lawrence, the co-founder of the youth-led climate organization Sunrise Movement, refused corpo...
          

        

        

          
Original Article

          

 

  

   

    
   

   
    
    
   
   
    
    
   
  

  

   

    

     

      Progressive candidate Will Lawrence of Michigan has defeated Republican incumbent Tom Barrett, flipping the state’s 7th Congressional District, a closely watched swing district that includes Lansing. Lawrence, the co-founder of the youth-led climate organization Sunrise Movement, refused corporate
      
       PAC
      
      money, instead building a people-powered grassroots mobilization campaign. He focused on lowering the costs of housing and healthcare, opposing the war on Iran, and challenging the power of Big Tech.
     

     

      “I’m fighting for a federal moratorium on new data center development, along with a pause on advanced AI development,” says Lawrence. “These developers come into small towns, and they say, ’We’re going to suck up a bunch of water. We’re going to use more energy than the current capacity of the grid. We don’t know what’s going to happen to your property values, but if everything goes well, we’re going to put 10 or 20 million people out of work, and if it goes poorly, we may kill everybody by accident.’”
     

     

      Lawrence also says he will back Hakeem Jeffries for House speaker, but that he will demand Democratic leadership listen to progressive concerns.
     

    

    

   

   

    
    

    

     

      Guests
     

     
    
      
  • 
       
    
        
    
         
          Will Lawrence
         
        
    
        
    
         Democratic congressmember-elect from Michigan’s 7th Congressional District and co-founder of the Sunrise Movement.
        
    
       
    
      
    • 
     

    

   

   

    Please check back later for full transcript.
   

   

    The original content of this program is licensed under a
    
     Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 United States License
    
    . Please attribute legal copies of this work to democracynow.org. Some of the work(s) that this program incorporates, however, may be separately licensed. For further information or additional permissions, contact us.
   

  

 




        

      

    
    

        

          
The hardest tarball

        

        

          Lobsters
        

	

	  stoppels.ch
	

        

          2026-11-10 08:47:03
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   
    Nov 7th, 2026
   
  

  

   Here is a curiosity: an archive that can be constructed using a single GNU tar invocation, that is extracted in 8 distinct ways depending on what tool you use.
  

  
$ printf hello > file
$ touch empty
$ tar --format=pax --pax-option='delete=?time,size:=512' \
      --transform='s,^\./file$,café,' \
      -cf hardest.tar file ./file empty

  

   It creates an archive
   
    hardest.tar
   
   from three files
   
    file ./file empty
   
   in sequence, where
   
    file
   
   is repeated so that GNU tar stores the second one as a hard link, and
   
    empty
   
   is empty. Exploiting the unique path of the second entry, the hard link is renamed to
   
    café
   
   . This triggers tar to create a pax header to store the file name as UTF-8. We add a
   
    size=512
   
   record to the pax header, which overrides the default
   
    size=0
   
   from the hard link. The value 512 is not a coincidence: it is exactly the size of a tar header.
  

  

   Visually, this archive has the following structure, with two basic interpretations based on whether a hard link can have a size or not.
  

  

   The structure of hardest.tar, with two basic interpretations based on whether a hard link can have a size or not.
  

  

   Now, POSIX says that data blocks for a hard link
   
    “may be included”
   
   in pax archives, but the implications of this are not entirely clear. So the 512 bytes after the hard link are its data, and not the header of
   
    empty
   
   as we archived it? How can a hard link have different contents from its previous counterpart
   
    file
   
   ?
  

  

   Extracting it
  

  

   This archive gives by far the richest and most surprising results I've encountered so far when extracting it with well-known tar utilities and libraries. The results below were produced using the latest releases of all packages at the time of writing.
  

  

   GNU tar, BusyBox, Python, Go and Perl
  

  

   This group is reasonable in principle: they ignore the size on the hard link, and extract
   
    file
   
   , its hard link
   
    café
   
   , and
   
    empty
   
   .
  

  

   bsdtar
  

  

   This is the system
   
    tar
   
   utility of macOS, which is closer to POSIX in spirit regarding the concept of size on hard links, and writes the 512 bytes into the hard link. The end result is that
   
    file
   
   now contains the tar header of
   
    empty
   
   .
  

  

   7-Zip, node-tar, tar-fs, and Rust's tar & astral-tokio-tar
  

  

   This group agrees with bsdtar that the 512 bytes are data of the hard link, but doesn't write them into the hard link. Instead, they skip forward over the data, and you are left with just
   
    file
   
   and
   
    café
   
   , without
   
    empty
   
   .
  

  

   Java's Commons Compress
  

  

   This is where you begin to need more imagination. Because
   
    café
   
   contains data, a
   
    separate
   
   file is created that contains the header of
   
    empty
   
   as data, while
   
    file
   
   keeps its original contents.
  

  

   PHP's PharData
  

  

   Makes
   
    café
   
   a separate, empty file, and also extracts
   
    empty
   
   . Why not?
  

  

   RubyGems
  

  

   Does not extract
   
    café
   
   at all, but to make up for it, it creates an empty directory
   
    PaxHeaders
   
   next to
   
    file
   
   and
   
    empty
   
   .
  

  

   R
  

  

   R has an entirely different approach: it extracts
   
    empty
   
   with 512 null bytes. It mistakenly applies the size to
   
    empty
   
   instead of the hard link, and those 512 bytes are from an end-of-archive marker.
  

  

   Bonus: Haskell
  

  

   Haskell's tar would be exactly like GNU tar, if only it did not have string decoding issues, which turn the file
   
    café
   
   into
   
    café
   
   on disk (in the year 2026, this is not a rendering quirk of your browser).
  

  

   .NET, Julia and uv's tar-codec
  

  

   These implementations reject the tarball. I believe this is the best thing you can do, even if it's technically not POSIX-compliant.
  

  

   More of this
  

  

   This tarball is one of 134 tricky tarballs that I'm collecting and categorizing in my test suite
   
    haampie/tar-minefield
   
   , developed since the last post. Its website
   
    https://stoppels.ch/tar
   
   features a big table that shows how implementations deal with all these cases, as well as detailed info per test case. A variant from the tarball of this post
   
    is included as a test case
   
   .
  

  

   If you'd like to discuss this, send me an email at
   
    firstname[at]lastname.ch
   
   .
  

 




        

      

    
    

        

          
John Goerzen: The Large Project Bias of CVEs

        

        

          PlanetDebian
        

	

	  changelog.complete.org
	

        

          2026-11-10 08:42:23
        

        

          
          

            I recently discovered some vulnerabilities in C-Kermit, one dating back to 1984.  I tried to do the reasonable thing: create advisories with CVEs.
That turns out to be pretty difficult for a small independent project.
Large projects have a way to self-assign CVE IDs.  They are their own CVE Numberin...
          

        

        

          
Original Article

          

 

  

   
   

    

     I recently
     
      discovered some vulnerabilities in C-Kermit
     
     , one dating back to 1984.  I tried to do the reasonable thing: create advisories with CVEs.
    

    

     That turns out to be pretty difficult for a small independent project.
    

    

     Large projects have a way to self-assign CVE IDs.  They are their own CVE Numbering Authority (CNA).  There is a
     
      massive list of CNAs
     
     .  Just looking at the first page of results, I see everyone from Airbus to 9front (the niche Plan 9 OS).  The
     
      OpenKermit project
     
     is not a CNA.
    

    

     If you’re a CNA, you can create and publish CVEs on your schedule.  There is apparently no external review process.  You can wait for months, or publish immediately.
    

    

     If you’re not a CNA, you have to find someone that is.  The general ones that are CNAs appear to be Github and MITRE.
    

    

     Since C-Kermit is
     
      hosted on Github
     
     , I thought I would go that route.  I followed the documented procedure: created Github
     
      security advisories for C-Kermit
     
     , then clicked the request CVE button for each.  The documentation states they will
     
      typically review within 72 hours
     
     .
    

    

     It’s been a week and a half and no sign of a review yet.  Apparently the real review time is
     
      more than a month
     
     .
    

    

     The other option for projects without a CNA is via MITRE.  You have to use a
     
      strange and often broken web form
     
     , logging in with either Google or Gitlab.  (It seems to be broken on Firefox).  Then you submit your request and wait.
    

    

     How long do you wait on MITRE?  It seems it could be
     
      anywhere from a day to several months
     
     .
    

    

     The first CVE I obtained for C-Kermit was CVE-2025-68920.  At the time, I had not yet started the OpenKermit project.  That issue was found and fixed in the context of my work maintaining C-Kermit for Debian, and Debian is a CNA.
    

    

     These were discovered while wearing my “upstream C-Kermit maintainer” hat.  I’m sure I could ask Debian for CVEs again, but that seems a bit cheating; not everyone that maintains a FLOSS project will have connections with a distro like I do.
    

    

     There are a lot of components of a modern OS and Internet ecosystem that are small projects without a large institution behind them.
    

    

     This bias towards large organizations when it comes to communicating security problems benefits nobody.  It doesn’t benefit users, and only serves to discourage timely communication.  Not everyone is as persistent as I am, and when it is made so difficult to make announcements — which seem to go into a giant black hole — it’s easy to say, “why bother?”
    

    

     By Microsoft’s own admission, they are under-funding their CVE process on Github (which may also be poorly-designed).  They blame it on increasing load due to LLMs — a problem they helped create and predicted!  Having a fiction about being able to communicate a security issue in a reasonable time is worse than not offering the path at all.
    

    

     Linux was once a student’s experiment.  Let’s not pretend that quality only matters from large projects.
    

   

   
   
  

  
  
  
  
 




        

      

    
    

        

          
"We Have to Be Brave": Palestinian Journalist Abed Abu Shehadeh Speaks Out After Israeli Detention

        

        

          Democracy Now!
        

	

	  www.democracynow.org
	

        

          2026-11-10 08:35:52
        

        

          
            

          
          

            The prominent journalist Abed Abu Shehadeh, a Palestinian citizen of Israel, has been released from Israeli custody after five days in detention. He was arrested on Wednesday by armed police and Shin Bet agents who conducted a nighttime raid on his home in the Israeli city of Jaffa. Abu ShehadehR...
          

        

        

          
Original Article

          

 

  

   

    
   

   
    
    
   
   
    
    
   
  

  

   

    

     

      The prominent journalist Abed Abu Shehadeh, a Palestinian citizen of Israel, has been released from Israeli custody after five days in detention. He was arrested on Wednesday by armed police and Shin Bet agents who conducted a nighttime raid on his home in the Israeli city of Jaffa. Abu Shehadeh’s detention was related to his reporting on the October 27 Israeli election and the role of Palestinian political parties. Ahead of the election, he interviewed Azmi Bishara, a Palestinian intellectual and former member of the Israeli Knesset who has lived in exile in Qatar since fleeing Israel amid allegations that he aided Hezbollah during the 2006 Lebanon war. Israeli authorities detained Abu Shehadeh on suspicion of “contacting a foreign agent,” in connection to his interview with Bishara.
     

     

      “Men with ski masks knock on your door at 11 at night. They tell you that they have an arrest warrant. They raid the house. They wake your wife, your children,” says Shehadeh. “It tells how messianic and dangerous the extreme right in Israel has become, willing to use this unprecedented power against journalists.”
     

    

    

   

   

    Please check back later for full transcript.
   

   

    The original content of this program is licensed under a
    
     Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 United States License
    
    . Please attribute legal copies of this work to democracynow.org. Some of the work(s) that this program incorporates, however, may be separately licensed. For further information or additional permissions, contact us.
   

  

 




        

      

    
    

        

          
Pentagon Whistleblower Wes Bryant: Impeach Hegseth. He's a "Clear & Present Danger" to Democracy

        

        

          Democracy Now!
        

	

	  www.democracynow.org
	

        

          2026-11-10 08:15:35
        

        

          
          

            The House of Representatives is moving toward a vote this week on whether to impeach Secretary of Defense Pete Hegseth. Outgoing Republican Congressmember Thomas Massie of Kentucky introduced eight articles of impeachment against Hegseth on Monday. They include violating the 1973 War Powers Resoluti...
          

        

        

          
Original Article

          

 

  This is a rush transcript. Copy may not be in its final form.
 

 

  

   
    
     AMY
    
    
     GOODMAN
    
    :
   
   The House is moving towards a vote this week on whether to impeach Secretary of Defense Pete Hegseth. The outgoing Republican Congressmember Thomas Massie of Kentucky introduced articles of impeachment against Hegseth on Monday for violating the Constitution and ignoring the will of Congress.
  

  

   

    
     
      REP
     
     .
     
      THOMAS
     
     
      MASSIE
     
     :
    
    Wherefore, Secretary of Defense Peter Hegseth, by such conduct, has demonstrated that he will remain a threat to the Constitution if allowed to remain in office, and has acted in a manner grossly incompatible with his duties and the rule of law. Peter Brian Hegseth thus warrants impeachment and trial, removal from office and disqualification to hold and enjoy any office of honor, trust or profit under the United States.
   

  

  

   
    
     AMY
    
    
     GOODMAN
    
    :
   
   Congressmember Massie introduced eight articles of impeachment against Hegseth, including violating the 1973 War Powers Resolution by continuing to attack Iran after Congress ordered the Trump administration to stop, illegally waging war against Yemen, ignoring laws designed to reduce civilian casualties, overseeing extrajudicial killings by bombing the boats of alleged drug traffickers in the Caribbean and eastern Pacific, abducting President Nicolás Maduro of Venezuela without congressional authorization, and suppressing the free speech rights of Democratic Senator Mark Kelly in retaliation for his participation in a video reminding troops not to obey illegal orders.
  

  

   Only a few Republican defectors in the House would be needed for a simple majority to impeach, setting up a Senate trial that could remove Hegseth from office.
  

  

   In anticipation of the potential impeachment vote, Defense Secretary Hegseth posted a video on social media last week defending his record. He was standing in front of a sign that said “Department of War.” This is some of what he said.
  

  

   

    
     
      DEFENSE
     
     
      SECRETARY
     
     
      PETE
     
     
      HEGSETH
     
     :
    
    But why do the Democrats and the deep state radicals really hate us? Because we tore down their sacred cows, one by one and without apology.
    
     DEI
    
    is a Marxist ideology built to destroy us, so we crushed it. … Patriot extremism, it’s not a thing. Patriots are now in control. Being trans is a mental illness incompatible with military service. … Military bases should not be renamed in the name of understanding “white rage.” … Narcoterrorists should die, not be caught and released. … Sealing the border and mass deportations are military functions. And when we say that Iran will not have a nuclear weapon, we actually mean it. … We will stand. We will fight. And we will defend this republic from all enemies, foreign and domestic.
   

  

  

   
    
     AMY
    
    
     GOODMAN
    
    :
   
   President Trump and Secretary of State Marco Rubio say they’re standing by Hegseth. Trump spoke to reporters Sunday.
  

  

   

    
     
      PRESIDENT
     
     
      DONALD
     
     
      TRUMP
     
     :
    
    A lot of people agree. And Pete Hegseth, so he wins two wars. We won in Venezuela. We’ve taken out hundreds of billions of dollars. We won in 48 minutes. And we won in Iran. … So, when you say about Pete Hegseth, I mean, he’s guilty of two things: basically, winning two wars.
   

  

  

   
    
     AMY
    
    
     GOODMAN
    
    :
   
   As we go to broadcast, Hegseth is holding a rare press briefing at the Pentagon, the first in something like half a year. He called the impeachment charges a farce and a stunt. The last time he addressed reporters was in May.
  

  

   For more, we’re joined by retired Master Sergeant Wes J. Bryant, spent 20 years in the U.S. Air Force as a special operations targeting specialist. He also served as chief of civilian harm assessment at the Pentagon from ’24 to ’25. The office was dissolved after President Trump returned to the White House. Wes Bryant is joining us from Raleigh, North Carolina.
  

  

   Wes, you’re speaking as Hegseth is speaking in Washington, D.C., defending himself. I first want to go to the office that you were chief of. What was it? The civilian harm. It was the — you were chief of civilian harm, the reduction unit at the Pentagon, which was shut down. Was that by Hegseth or Trump? And explain what that did and what these articles of impeachment mean.
  

  

   
    
     WES
    
    
     BRYANT
    
    :
   
   Yeah. You know, yeah, I was a chief of civilian harm assessment at what was called the Civilian Protection Center of Excellence at the Pentagon, under a new construct that came up, ironically, under the first Trump administration initially, and then was codified into law under the Biden administration, what was called the Civilian Harm Mitigation and Response Enterprise. And, of course, you know, Hegseth, that was one of the so-called woke programs that was attacked immediately, and he effectively dismantled and shut it down. And, of course, I was pushed out after whistleblowing about all of that.
  

  

   And, you know, looking at the articles of impeachment — I mean, let’s just look at Hegseth’s spectacle on Thursday. I mean, that video, in and of itself, should be enough to impeach this man — his violent religious extremism, his emotional instability, his psychological volatility, you know, and during that couple-of-minute broadcast, he made direct overtures toward threatening the American people, namely what he calls, you know, his political enemies, the so-called radical Democrats, with use of military force. That, in and of itself, is enough.
  

  

   But then, let’s look at the articles of impeachment, which lay out all of the various violations, constitutionally, against standing U.S. law, against U.S. military law and policy, and against international law and U.N. Charter, for all of these illegal wars that he’s waged, Venezuela, invading Venezuela, abducting a head of state, invading — a mass bombing campaign in Yemen, a mass bombing campaign in Iran. And then we have his attacks against the press and free speech, his use, increasing use, of the military domestically against the American people, and further threats to use the military under the Insurrection Act.
  

  

   So, you know, Hegseth truly presents a clear and present danger to this democracy, to America, to the free world. Under Hegseth, you know, the U.S. military has been hijacked, and America has become, has portrayed itself to the world as a far-right dictatorship bent on global domination, and Hegseth and his wielding of the U.S. military with free rein from Donald Trump is really the primary enforcer of that.
  

  

   
    
     JUAN
    
    GONZÁLEZ:
   
   And, Wes Bryant, I wanted to ask you about one of the — one of the points that Massie mentions in his impeachment resolution is also the targeted killings or the so-called boat strikes of alleged drug traffickers in the Caribbean and eastern Pacific. Could you respond to that in particular, given the fact that it’s not just Hegseth, but there had to be a lot of people down the military chain who followed orders in these — attacking people that there’s no evidence, number one, that they were actually drug trafficking or, two, that they should be executed even if they were drug trafficking?
  

  

   
    
     WES
    
    
     BRYANT
    
    :
   
   Right, exactly. This is just incredibly shameful. These so-called narcoterrorism strikes have been shown to be, you know, by both current and former military lawyers and other government lawyers, State Department, for example, to be completely illegal, out of accordance with U.S. law and especially with international law. That’s whether they are civilians or whether they are drug traffickers. The term “narcoterrorism” actually doesn’t even fit doctrinally within the U.S. military’s own term, own definition of “terrorism.”
  

  

   So, when, you know, people ask me, as an expert in civilian harm, as an expert in strike operations, that spent 20 years in the U.S. military carrying these operations out — when people ask me, “Does the U.S. military intentionally target civilians?” I would have previously said “no.” But now I’ll say “absolutely,” because we have targeted on order of over a couple — over 200 civilians in these so-called narcoterrorism strikes. These are clear and blatant war crimes.
  

  

   And again, as you mentioned, Hegseth is not only to blame. You know, I stated a year ago, when I first whistleblew about the dismantling of civilian harm protections and everything else, all the other threats Hegseth presented, that I believed our senior military commanders — Bradley, Cooper, General Caine — would be the shield against the unlawful and unethical use of the U.S. military. We’ve seen the exact opposite. Hegseth’s pushed out everyone who may have dissented, and everyone who remains is either in line or weak and complicit. And yes, these senior combatant commanders, these senior military lawyers, and even down to some of the operational level, need to be held accountable for these crimes.
  

  

   
    
     JUAN
    
    GONZÁLEZ:
   
   And can you also elaborate on Hegseth’s lethality doctrine, his Christian nationalist views, and why you see him as fundamentally unfit?
  

  

   
    
     WES
    
    
     BRYANT
    
    :
   
   Right. You know, internally, Hegseth’s ideology is one of a Christian nationalism, actually a white Christian nationalism, that’s rooted in this — in misogyny, in a racial and religious supremacy, and rooted in dehumanization. It’s really — it’s a perverted version of Christianity, that is to pure Christianity what the Sharia of
   
    ISIS
   
   and the Taliban is to Islam. There’s truly no difference here.
  

  

   And so, what he’s trying to do is infuse this ideology within the U.S. military, and then it also feeds his very ethos, you know, his so-called revival of the warrior ethos, and then his lethality doctrine, which is truly based on dehumanization, and it ignorantly reduces the U.S. military’s mission to just lethality and killing. You combine this with his fixation on hypermasculinity, which, frankly, is reminiscent of the Aryan movement of the Third Reich, what Hitler’s Nazi Germany called the “new German man,” and now you have this amalgamation of worldview and outlook combined with an application into the operational use of the U.S. military that becomes just an outlook of killing and destruction, and a reveling in and glorification of war.
  

  

   Then you have his disdain, you know, his blatant, overt disdain, for rules of engagement, Geneva Conventions, the laws of war. And now you combine all of this together, and along with weak and complicit military command, and it’s no wonder that we have atrocities being carried out, that we have all of these illegal wars and operations being carried out.
  

  

   
    
     AMY
    
    
     GOODMAN
    
    :
   
   Retired Master Sergeant Wes Bryant, could you — you listed some of the people going up the chain of command, but it’s hard to not see Hegseth really as a surrogate for taking on Trump. When you look at these articles of impeachment — violating the War Powers Resolution, ignoring laws that minimize civilian casualties, these extrajudicial killings in the Caribbean and the Pacific — ultimately, this is President Trump who’s ordering this, and he’s carrying out his orders, isn’t he?
  

  

   
    
     WES
    
    
     BRYANT
    
    :
   
   Absolutely. You know, Hegseth should be the first domino. Trump should absolutely be impeached and removed and indicted, just as Hegseth should, just as many of our senior military leaders should at this point. But, you know, I think the reality here is that Hegseth is the first and most realistic target, so we need to pursue removing him. And, you know, frankly, if Congress doesn’t have the will or the backbone collectively, the American people must absolutely demand Hegseth’s removal. And, you know, I, for one, would be more than willing to lead that charge. And then let’s go after Trump and the rest of the administration following.
  

  

   
    
     AMY
    
    
     GOODMAN
    
    :
   
   And the not minimizing civilian casualties — the unit actually that you were chief of, the civilian harm assessment at the Pentagon, you did that for a year. Are we talking about both in the case of Iran, Iranians, like the children in Minab, when the U.S. — it looks overwhelmingly that the evidence is the U.S. bombed the girls’ school in southern Iran; the Pentagon hasn’t come out with a report on this, though they said they were going to — but also U.S. troops and civilians in the area of the Gulf when they waged war on Iran, all of these bases where Americans were wounded? But start with the Iranians and what this unit for civilian harm assessment was that was shut down in the Pentagon.
  

  

   
    
     WES
    
    
     BRYANT
    
    :
   
   Yeah, you know, the Civilian Harm Mitigation and Response Enterprise consisted of a few hundred individuals, spread across the Pentagon and the combatant commands, that were there to do exactly this. You know, if they had been emplaced at the Central Command, for example, if those personnel had been overseeing the strike planning for every single target set in Iran, I promise that a strike as egregious of a failure as Minab would not have happened.
  

  

   And then you have the detractions, the devolutions of operational practice and standards in general, where, you know, even aside from my unit that existed, the Civilian Harm Enterprise, the U.S. military has been violating standing doctrine and practices in targeting and civilian harm mitigation that even existed over the course of the past 20, 30 years. You know, you combine this with Hegseth’s deemphasis on the protection of civilian, his glorification of and reveling in war and violence, his direction — his directives to carry out mass bombing campaigns, and what I believe is his directives that he’s making, you know, over secured lines or in secured areas to the commanders themselves, so that they’re unrecorded, to actually have a higher tolerance for civilian casualties. We’ve got this incredible spike in civilian casualties, not just Minab in Iran. It’s upwards of 3,000-plus potential civilians killed, along with, you know, massive destruction of civilian infrastructure, even targeting of cultural heritage sites, hospitals, schools — more than just Minab — police and fire entities, vital energy infrastructure. So, it’s incredible, what we’re seeing, this devolution of the U.S. military under Hegseth.
  

  

   
    
     JUAN
    
    GONZÁLEZ:
   
   And, Wes Bryant, I’m wondering: During the period of the Biden administration, did you encounter in your — in that unit particularly glaring attacks that affected civilians that may not have gotten much attention?
  

  

   
    
     WES
    
    
     BRYANT
    
    :
   
   No, you know, I wouldn’t say so. Most of the — you know, we’ve had, obviously, civilian harm incidents in the past. Look at the withdrawal from Afghanistan in 2021, where the U.S. struck an aid worker and children, his family. You know, that was one of the catalysts to kickstart the Civilian Harm Mitigation and Response Enterprise. You have — going back before that, you have some instances in the fights against
   
    ISIS
   
   in Mosul, Raqqa. You have the 2015 very tragic strike against a
   
    MSF
   
   hospital, a Doctors Without Borders hospital, in Afghanistan.
  

  

   And, you know, what we were doing under the Civilian Harm Mitigation and Response Enterprise, and collectively, as a joint force, at all the combatant commands, was doing a really hard look back up through the Biden administration of what the U.S. did right during the “war on terror,” and all of the various failures and how we could improve those. And we had some pretty fantastic momentum, and that was all at full stop under this Hegseth regime.
  

  

   And we’ve devolved even past that. You know, we’ve gone back decades, frankly, in our application of precision, in our ability and, really, willingness to safeguard the innocent and carry out the war with humanity and honor, and to have accountability and transparency when failures happen. We see no transparency and the opposite of accountability from the Hegseth regime. I mean, he truly operates like a fascist military dictator — you know, totalitarian control and extremist nationalism and a hypermilitarism.
  

  

   
    
     AMY
    
    
     GOODMAN
    
    :
   
   Retired Master Sergeant Wes Bryant spent 20 years in the Air Force, was chief of civilian harm assessment at the Pentagon from 2024 to '25. We'll link to your new
   
    article
   
   in
   
    Zeteo
   
   headlined “I Worked at the Pentagon. Congress Must Impeach and Remove Pete Hegseth Now.”
  

  

   Coming up, we speak to Palestinian journalist Abed Abu Shehadeh. He was just released from five days in Israeli detention for his reporting related to the Israeli elections and the role of Palestinian parties. Stay with us.
  

  

   [break]
  

  

   
    
     AMY
    
    
     GOODMAN
    
    :
   
   “Tama,” “Greed,” by the Palestinian oud musician Huda Asfour, performing in our
   
    Democracy Now!
   
   studio.
  

 

 

  The original content of this program is licensed under a
  
   Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 United States License
  
  . Please attribute legal copies of this work to democracynow.org. Some of the work(s) that this program incorporates, however, may be separately licensed. For further information or additional permissions, contact us.
 




        

      

    
    

        

          
Don't buy AR glasses

        

        

          Hacker News
        

	

	  blog.yaros.ae
	

        

          2026-11-10 08:10:25
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   
    
   
  

  

   I was browsing the thread under
   
    this Mastodon post
   
   about how absurdly gamified the Temu app has become. Someone
   
    posted
   
   this
   
    
     decade
    
    -old video
   
   :
  

  
  

   It's sad and a little scary how
   
    HYPER-REALITY
   
   predicted the current state of web (and app) design, assuming you're not using a
   
    decent adblocker
   
   . Like the film
   
    Idiocracy
   
   , this is a video which has slowly turned from hyperbole into a chilling reflection of reality. All the same companies and individuals who turned the web into a gamified nightmare clusterfuck of banners and popups and dark patterns and enshittified services are going to race to do the same to AR if it becomes mainstream. There's no reason to suspect otherwise.
  

  

   All this leads me to ask, what actual incentive (aside from short term conveniences) would I have to buy an AR device? You don't
   
    need
   
   an AR device. And you can't become dependent or reliant on a device you haven't yet bought. So don't buy one!
  

  

   You're not always expected to have your phone out. Most of the time, it should be in your pocket. Despite an epidemic of absentminded people walking around glued to their phones (I'm as guilty as anyone), it's still considered bad etiquette to use them during dinner, or while crossing the street. That's not the case with glasses, which are designed to be worn all day. That will become the
   
    expectation
   
   for AR glasses as they evolve into lighter, sleeker devices. All the same apps and services keeping you tied to your phone will follow you over to AR. Is that what you want?
  

  

   Do you really want the hellscape end-state of the modern attention economy grafted onto your fucking face? To see ads everywhere all the time? Why? Even if you currently own an AR device and are enjoying a clean, uncluttered, curated user experience, how long do you think that will last? The web didn't turn into what it is overnight. Things take time to enshittify, but it's bound to happen.
  

  

   Pop-up windows were a plague in the 90s and early 2000s, and remained that way until browsers started blocking them by default. This forced the popups to migrate
   
    into the pages themselves
   
   , and they've been trapped there ever since. Well, AR will be the escape hatch through which they break free of the constraints of the browser window and escape into the "real" world. Is that what you want?
   
    REAL-WORLD POPUPS?
   
   Are you insane?
  

  

   I don't know exactly how, I don't know exactly when, but Apple and Google and Meta will create their own frameworks for businesses to display interfaces and ads and popups in arbitrary places, and it will spiral out of control. History will repeat itself.
  

  

   Keep using your smartphone. Don't become dependent on an always-on HUD. Put up some resistance. If they want to envelop you within the cyberpunk dystopia, they should be forced to drag you inside it kicking and screaming.
  

  

   
    #hardware
   
   
    #rant
   
   
    #software
   
   
    #web
   
  

 




        

      

    
    

        

          
‘Without storyboards, I feel like I’m in Grand Central station in my underwear’: film’s fightback against AI

        

        

          Guardian
        

	

	  www.theguardian.com
	

        

          2026-11-10 08:00:24
        

        

          
            

          
          

            As Hollywood begins to adopt the technology, the professionals in most direct jeopardy are the illustrators mapping out directors’ first visions. They sketch out what could be lost A film industry dominated by AI is a dystopian prospect: stories and dialogue generated by large language models, popul...
          

        

        

          
Original Article

          

 

  

   
    A
   
   film industry dominated by AI is a dystopian prospect: stories and dialogue generated by large language models, populated by
   
    reincarnated screen icons
   
   and
   
    uncanny humanoids
   
   . That is in the future, but the real-world impact of AI is already directly affecting jobs behind the scenes, as Hollywood’s biggest film-makers begin to adopt the technology. James Cameron – long an advocate for emerging technologies in film-making – is
   
    on the board of a gen AI firm
   
   , citing his interest in how AI will intersect with CGI; Steven Soderbergh used Meta-powered tech to create animations for his
   
    recent documentary about John Lennon
   
   ; even Christopher Nolan, while dismissing the idea that AI will replace humans as “nonsense”, conceded that it will create some useful “imaging tools”.
  

  

   

    
     
     
     
     
     
     
     Storyboard by Saul Bass for Psycho, depicting the shower murder scene in sketched panels
    
   

   

    
     
      
      
     
    
    
     Meticulous … Saul Bass’ storyboard for the shower scene in Alfred Hitchcock’s Psycho
    
    Photograph: TCD/Prod.DB/Alamy
   

  

  

   The current canary in the coalmine however is the storyboard artist, whose work gen AI appears to have directly in its sights. Storyboard artists are the illustrators who draw the panels of images with notes and diagrams that map out scenes before they are filmed. Storyboards are used to work out how a film will look, and as a blueprint to communicate a director’s vision to cast and crew
   
    ,
   
   and
   
   
   are one of the first steps in bringing a script off the page. Now they appear on the verge of replacement by programmes that use text prompts to create illustrations instead. Even an old-school diehard like Martin Scorsese has got on board; in June
   
    he announced a partnership with an AI firm
   
   whose text-to-image model he used in the storyboarding process for his next movie.
  

  

   Usually, storyboards are made together by a director, an artist and other crew members responsible for the film’s visual storytelling, such as cinematographers, editors, production designers, stunt co-ordinators and more. “I find it very fulfilling to make art in such a collaborative way,” says
   
    Alex Clark
   
   , a British storyboard artist whose recent films include Bong Joon Ho’s sci-fi comedy
   
    Mickey 17
   
   , adventure romance
   
    The Gorge
   
   and Louis Leterrier’s recent thriller
   
    The Last House
   
   . “It’s about people sitting down to discuss each other’s ideas. You might act things out, make sound effects, read dialogue. You develop a creative relationship with one another.”
  

  

   

    
     
     
     
     
     
     
     Storyboard sketch by Max Douy from Alejandro Jodorowsky's Dune shows an insect-like creature with spiny legs, displayed at a Shanghai exhibition
    
   

   

    
     
      
      
     
    
    
     Storyboard illustration by Max Douy for Alejandro Jodorowsky’s unproduced adaptation of Dune
    
    Photograph: Zhe Ji/Getty Images
   

  

  

   For Clark, the process of creating a storyboard is just as important as the finished product. “A common misconception is that storyboarding is about making nice drawings. But it’s more than that – it’s about relating to how the director is thinking, and conceiving the most appropriate ways to tell the story of a scene,” he says. Dune director
   
    Denis Villeneuve
   
   articulated this relationship when describing his frequent collaborator, artist Sam Hudecki, as “an extension of my brain”. For Villeneuve, storyboarding is “a new way of writing”: writing a screenplay might provide the words, but storyboarding is the first step in creating the “cinematic language of the movie”. He views it as “a way to dream” as the film begins to come to life on the page.
  

  

   Clark says that there is a balance that must be struck between “capturing the essence” of a scene and figuring out how the shots are going to work once the cameras are rolling. “The act of how you mark the page – to convey forms, tones, compositions, blocking and so on – forces you to thoroughly think about how all these different details will affect the scene. It gives you a rigorous understanding of how the scene is going to work.” Clark’s work reflects the fact that storyboarding is one step in an ongoing collaboration that continues through pre-production, shooting on set and beyond. “Sometimes I try to scale the drawings back, when it feels appropriate to leave space for others to build on it – whether it’s an actor’s performance, the way the set is decorated, lighting setup or subtle movement of the camera. I like finding space for happy accidents.”
  

  

   For researchers and film enthusiasts, storyboard art offers a glimpse into the journey that lies behind a film, including fascinating changes in direction like this. “Storyboard art shows us the evolution of the creative vision,” says Ferdinando Cocco, a lecturer in film at Abertay university in Dundee. He points to Disney’s 1991 film Beauty and the Beast as an example: when it was first being worked on in the late 1980s,
   
    the storyboards had a rococo-inspired aesthetic
   
   , contemporary to the fairytale’s origins, styling Gaston as a bewigged 18th-century French aristocrat rather than the swollen, strong-jawed hunter who exemplified more modern ideals of masculinity.
  

  

   

    
     
     
     
     
     
     
     Walt Disney (right) listens to an unidentified animator talk through the storyboards for the film Sleeping Beauty (released in 1959).
    
   

   

    
     
      
      
     
    
    
     Walt Disney (right) listens to an unidentified animator talk through the storyboards for the film Sleeping Beauty (released in 1959).
    
    Photograph: Gene Lester/Getty Images
   

  

  

   As a film-making technique, the storyboard was first used regularly by Disney animators in the 1930s and and it plays a key role in their production process (as evidenced by
   
    displays of concept and storyboard art
   
   , and the
   
    side-by-side videos Disney posts online
   
   . (Disney also announced
   
    a $1bn investment
   
   into OpenAI’s video tool Sora last year.)
  

  

   Storyboards were swiftly adopted by live-action productions, dating at least back to
   
    Gone With the Wind
   
   (1939). Since then, many film-makers have left behind storyboards that are beautiful and evocative images in themselves. Alfred Hitchcock created meticulously detailed storyboards, which spawned some of the genre’s most recognisable images: such as
   
    the shower scene in Psycho
   
   sketched beforehand by his frequent collaborator Saul Bass, the graphic designer behind many classic posters of the era. And before that, Hitchcock had worked with Salvador Dalí on
   
    surreal designs
   
   for the dream sequence in his 1945 film Spellbound.
  

  

   Other directors, including
   
    Akira Kurosawa
   
   and
   
    Ridley Scott
   
   – whose storyboards are known as “Ridleygrams” – draw their own. Some of Bong’s self-drawn sketches are currently
   
    on display at the Academy Museum in Los Angeles
   
   , and his panels for Parasite have been
   
    published as a graphic novel
   
   . “Whenever I go to set without storyboards, I feel like I’m standing in the middle of Grand Central Terminal wearing only my underwear,” Bong writes in the book’s preface – however he does encourage the reader to see the differences between the storyboards and the film as “exciting moments of fear and spontaneity”.
  

  

   

    
     
     
     
     
     
     
     Alfred Hitchcock sits sketching storyboards, surrounded by framed concept artwork on the floor
    
   

   

    
     
      
      
     
    
    
     Setting the tone … Alfred Hitchcock drawing storyboard sketches for Saboteur surrounded by concept artwork in his office at Universal Studios in 1942.
    
    Photograph: Masheter Movie Archive/Alamy
   

  

  

   Fan interest in behind-the-scenes material has created a market for storyboard books, while last year
   
    an exhibition devoted to storyboard art held in Milan
   
   displayed panels from films made by arthouse auteurs such as Ingmar Bergman and Federico Fellini, to artists Isaac Julien and Carrie Mae Weems, to Hollywood royalty – including Scorsese.
  

  

   Creating engaging images is not without a practical function either, as storyboards are often pinned up on set to give the crew a sense of what will be shot that day. “I feel a responsibility to produce work that inspires and captivates everyone about what they’re making,” Clark says. “If the level of artistry and attention is evident at this stage, I believe it can set the tone on set, of valuing the craft involved.”
  

  

   All hope is not yet lost. Cocco has observed a return to analogue practices and suggests that AI can be used in a way that fosters rather than dilutes the creative process. “Perhaps the difficulty that AI purportedly overcomes was the whole point from the start,” Cocco says. “Having to communicate with others forces an expansion of the artistic vision in ways that cannot be pre-empted.”
  

  

   Clark meanwhile predicts that, as AI usage in the industry increases, people will come to have a greater appreciation for films with a human touch. “Ultimately, I think most successful films make you feel something as a human being. One advantage of hand-drawn storyboards is that you have a direct sense of that human authenticity right there on the page.”
  

 




        

      

    
    

        

          
Headlines for November 10, 2026

        

        

          Democracy Now!
        

	

	  www.democracynow.org
	

        

          2026-11-10 08:00:00
        

        

          
            

          
          

            GOP Rep. Thomas Massie Introduces Articles of Impeachment Against Defense Secretary Pete Hegseth, Pentagon Retreats from Second U.K. Base Due to Alleged Threat from Iran, Trump Raises New Election Conspiracy Theory After Democrats Sweep Midterms, Schumer Faces Pressure to Step Aside as Chris Van Hol...
          

        

        

          
Original Article

          

 

  

   

    
     Headlines
    
    
     November 10, 2026
    
   

   

    

     
     
      Watch Headlines
     
    

   

  

  

   

    

     
      GOP
     
     Rep. Thomas Massie Introduces Articles of Impeachment Against Defense Secretary Pete Hegseth
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     

      Republican Congressmember Thomas Massie introduced articles of impeachment against Defense Secretary Pete Hegseth on Monday for “high crimes and misdemeanors.” The eight impeachment articles accuse Hegseth of violating the 1973 War Powers Resolution by continuing to attack Iran even after both chambers of Congress ordered the Trump administration to stop. He’s also accused of illegally waging war against Yemen, ignoring laws designed to reduce civilian casualties, overseeing “extrajudicial killings” in attacks on boats in the Caribbean Sea and eastern Pacific, abducting Venezuelan President Nicolás Maduro without congressional authorization, and suppressing the free speech rights of Democratic Senator Mark Kelly in retaliation for reminding troops not to obey illegal orders. Congressmember Massie outlined the charges during a speech from the House floor.
     

     

      

       
        Rep. Thomas Massie
       
       : “Wherefore, Secretary of Defense Peter Hegseth, by such conduct, has demonstrated that he will remain a threat to the Constitution if allowed to remain in office, and has acted in a manner grossly incompatible with his duties and the rule of law, Peter Brian Hegseth thus warrants impeachment and trial, removal from office and disqualification to hold and enjoy any office of honor, trust or profit under the United States.”
      

     

     

      It’s expected the House will vote on Hegseth’s impeachment on Wednesday. Only a few Republican defectors would be needed for a simple majority, setting up a Senate trial on whether to remove Hegseth. On Monday, President Trump said he would stand by Hegseth if he’s impeached.
     

     
    

   

   

    

     Pentagon Retreats from Second U.K. Base Due to Alleged Threat from Iran
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     

      The Wall Street Journal reports the Pentagon has evacuated aircraft from a second base in the United Kingdom due to another alleged threat from Iran. U.S. refueling tankers were reportedly moved from a base in Mildenhall on Monday. Last month, the Pentagon pulled B-1 bombers out of another British base.
     

     

      Meanwhile, Iran’s Islamic Revolutionary Guard Corps says two more ships, including a supertanker, are on fire near the Strait of Hormuz after using what Iranian officials have called an “unauthorized route.” Iran has claimed 11 strikes on ships over a 10-day span. The continued attacks on shipping came as Iran’s Foreign Ministry said it could reopen the strait within 48 hours if the U.S. agrees to Tehran’s list of demands.
     

     

      

       
        Esmail Baghaei
       
       : “If the U.S. meets the demands put forward by Iran, the situation in the region could see a positive shift in as little as two days, and security in the Strait of Hormuz could also be restored.”
      

     

     

      On Monday, President Trump spoke with Qatar’s prime minister, who’s acted as a mediator in efforts to end the war. After the talks, Trump claimed there was “positive momentum” in negotiations for a deal with Iran.
     

     

      

       
        President Donald Trump
       
       : “The military action doesn’t seem to be a very necessary thing, but we’re locked and loaded, ready to go for any reason that changes. Israel and the entire Middle East are protected from Iranian danger and threats, and we’re seeing momentum toward the end of this conflict. I think it’s going to be ending fairly soon.”
      

     

     

      Since the U.S. and Israel launched the war on Iran in February, Trump has claimed more than 40 times that the war was close to an end, that a deal was near, or that the war was already over.
     

    

   

   

    

     Trump Raises New Election Conspiracy Theory After Democrats Sweep Midterms
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     Image Credit: Lauren Boebert for Congress
    

    

     

      Democrats are continuing to build on their historic wins in last week’s midterm elections as votes continue to be counted. In Mississippi, Scott Colom’s lead over Republican incumbent Senator Cindy Hyde-Smith has topped 2,500 votes, with just two batches of ballots left to be counted before a Friday deadline to certify the results.
     

     

      In Colorado, Republican Congressmember Lauren Boebert is trailing in her bid to hold on to her seat. On Monday,
      
       CNN
      
      projected Boebert will lose the race to Democrat Eileen Laubacher, a retired U.S. Navy admiral who served on the National Security Council under President Joe Biden.
     

     

      On Monday, President Trump reversed his previous comment that he was “absolutely willing” to accept the results of the midterm elections. Trump wrote on his Truth Social platform, “Does anybody really believe that this 'Election' was honest. How could the Polls be so wrong???”
     

    

   

   

    

     Schumer Faces Pressure to Step Aside as Chris Van Hollen Hints at Run for Senate Majority Leader
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     

      Senate Democrats could be headed for a leadership shakeup, after Maryland Senator Chris Van Hollen indicated Monday he’s open to running for Senate majority leader when the new Congress convenes in January. A source close to Van Hollen told Politico the Maryland Democrat is thinking about a run after he “received an outpouring of calls and is now in active listening mode. The door is not shut.”
     

     

      This comes as a growing number of Senate Democrats have called for new leadership or refused to commit to supporting New York Senator Chuck Schumer for majority leader. Joining the call is a major labor union, the International Association of Machinists and Aerospace Workers, which wrote in a letter to Schumer on Monday, “We believe this is the right moment for a new generation to lead Senate Democrats.”
     

     

      Meanwhile, Connecticut Democratic Senator Richard Blumenthal said he’s open to new leadership if a challenger to Schumer emerges.
     

     

      

       
        Sen. Richard Blumenthal
       
       : “But we need to have a conversation about leadership going forward, because we need new energy and ideas.”
      

     

    

   

   

    

     Senate Advances Bill to Speed Construction of Fossil Fuel Projects and Data Centers
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     Image Credit: USA TODAY Network
    

    

     

      In more news from Capitol Hill, the Senate voted 73 to 25 Monday to take up a sweeping permitting reform bill. It was advanced by nearly every Republican and 22 Democrats. Environmental groups have called the legislation an “aggressive attack on federal environmental protections in order to facilitate rapid, unregulated development of fracked gas power plants, dirty fossil fuel pipelines, and expensive hyperscale data centers.” Meanwhile, Indigenous leaders, including New Mexico Governor-elect Deb Haaland, argue the bill would undermine tribal sovereignty.
     

     

      More than 160 health, consumer, religious and environmental groups are calling on Congress to instead pass the No AI Data Centers on Federal Lands Act. It’s sponsored by Michigan democratic socialist Congresswoman Rashida Tlaib, who said, “[The] elections send a clear message that Americans want their representatives to protect their health and environment, not sell them out to Big Tech and Big Oil.”
     

    

   

   

    

     5 Arrested at Anthropic’s
     
      NYC
     
     Offices as Protesters Demand Halt to
     
      IPO
     
     Plans
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     

      Here in New York, activists with Climate Defenders, New York Communities for Change and Planet Over Profit protested at Anthropic’s Manhattan offices for over an hour on Monday. Five of them were arrested for blocking the employee security entrance. The protesters blasted Anthropic’s moves toward an initial public offering that could see it valued at $1.4 trillion — far less than previous estimates it could be worth as much as $2 trillion. This comes after major global tech stocks fell sharply last week following the U.S. midterm elections, which sparked concerns among investors that the Democratic takeover of both chambers of Congress will mean tougher regulation of AI. This is activist Jonathan Westin speaking to Democracy Now! as he was being arrested.
     

     

      

       
        Jonathan Westin
       
       : “I’m getting arrested because we’re trying to stop Anthropic from crashing the global economy, along with AI. They are not worth the paper they’re printed on. Millions and millions of lives will be affected by it.”
      

     

    

   

   

    

     African National Congress Suffers Its Worst Election Result Since South Africa Ended Apartheid
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     

      In South Africa, the African National Congress, the party of Nelson Mandela, suffered its worst results in local elections on Sunday. The
      
       ANC
      
      won just 31% of the vote, though it remains South Africa’s largest party. Its main rival, the Democratic Alliance, said it won the votes of more than 1 million Black South ⁠Africans for the first time.
     

    

   

   

    

     Dozens Drown in Capsized Boats While Attempting to Reach European Soil
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     

      At least 39 migrants have died after a small wooden boat capsized off the Atlantic coast of Senegal as it tried to reach Spain’s Canary Islands. This year alone, the Spanish immigrant rights group Walking Borders has recorded over 600 migrants’ deaths in the Atlantic, as more people desperately flee war, famine and climate disasters and attempt to reach Europe. This comes as at least 22 people have died while attempting to reach Greece from Libya over the course of three days.
     

    

   

   

    

     U.S. Cancels Deportation Flight of Iranians at Last Minute
    

    

     
      Nov 10, 2026
     
    

    

     

      Back in the United States, a deportation flight carrying Iranian nationals to Iran via Pakistan was abruptly canceled Sunday morning, after at least eight Iranians had been loaded onto a plane in Mesa, Arizona, bound first for the Republic of Georgia. The flight would reportedly have been the first deportation of Iranians since the U.S. launched attacks on Iran in February. Back in October, U.S. District Judge Ana Reyes ordered the U.S. government to give the court 24-hour notice of any plans to deport Iranians to Iran or to any other country, and five days’ written notice before deportation is carried out.
     

    

   

   

    

     
      ICE
     
     Detains 8-Year-Old Haitian Boy in San Diego After Routine Immigration Check-In
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     Image Credit: NBC San Diego
    

    

     

      In San Diego, an 8-year-old Haitian boy is in federal custody after
      
       ICE
      
      detained him at a scheduled immigration appointment. He had been living with his uncle since his father was deported last year.
      
       DHS
      
      says the uncle could not establish legal guardianship. Guerline Jozef, executive director of Haitian Bridge Alliance, said, “This is not child protection. This is state-inflicted trauma disguised as immigration enforcement. An eight-year-old child should be sitting in a classroom, learning, playing, and dreaming about his future, not being taken away and retraumatized by armed federal agents. His father has already been taken from him and deported, now this administration has stripped him of the stability, family, and community every child deserves.”
     

     
    

   

   

    

     
      SCOTUS
     
     Allows Trump Admin to Resume Border Wall Construction in Big Bend National Park
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     Image Credit: X/@LaikenJordahl
    

    

     

      The U.S. Supreme Court is allowing the Trump administration to resume the construction of a new border wall in Big Bend National Park and along more than 500 miles of the Rio Grande in Texas. Monday’s ruling lifted a lower court’s temporary injunction that blocked construction back in October while a lawsuit filed by the Center for Biological Diversity and others is resolved. Justice Ketanji Brown Jackson was the only Supreme Court member to dissent.
      
       Click here to see our coverage of this story
      
      .
     

    

   

   

    

     Proposed
     
      USDA
     
     Policy Would Cut Food Aid for Millions of People
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     

      An estimated 6.3 million people in the U.S. could lose their food assistance by 2029 over a new proposed policy set forth by the Department of Agriculture. The Republican-backed measure would toughen restrictions on people’s eligibility for the Supplemental Nutrition Assistance Program. The policy change could also leave millions of children without access to free school meals.
     

    

   

   

    

     New York Focus Uncovers 2023 Sexual Assault Lawsuit by Two Former Cornell Students
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     

      The news outlet New York Focus has uncovered a 2023 lawsuit in which two former Cornell students say the university’s Title IX office ignored their complaints that the same male student sexually assaulted them in 2018 and 2021. A complaint filed by one of the students and their lawyer says, “At least five to ten others are known to have been sexually abused and it is believed that many more were abused but have yet to come forward.” Cornell University and the male student tried to have the case dismissed, but a trial is scheduled for next year. The lawsuit follows another high-profile lawsuit filed by Jane Doe in September over an alleged fraternity gang rape at Cornell in 2024, prompting a massive public outcry and leading to New York Attorney General Letitia James ordering a new investigation.
     

    

   

   

    

     Russell Brand Sentenced to 10.5 Years in Prison
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     

      In the United Kingdom, the comedian, actor and podcaster Russell Brand has been sentenced to 10 years and six months in prison for raping a fan and sexually assaulting three other women. The abuses occurred between 2004 and 2009 at the peak of Brand’s career. This is Judge Joel Bennathan.
     

     

      

       
        Judge Joel Bennathan
       
       : “About 20 years ago, Russell Brand, you were becoming famous. You were clever and, in many people’s eyes, funny and charismatic. You had also become a sexual predator.”
      

     

    

   

   

    

     Proposition 40 Billionaire Tax Fails to Pass in California
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     

      In California, Proposition 40, a one-time 5% wealth tax on individuals and trusts with over $1 billion in assets, has failed to pass. Democratic Governor Gavin Newsom was an opponent of the wealth tax, while Democratic Congressmember Ro Khanna of California was in favor of the tax.
     

    

   

   

    

     Online Magazine Salon Closes After 31 Years of Publication
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     

      The progressive online magazine Salon has abruptly shut down after 31 years of publication. Salon was widely celebrated as a trailblazer for digital journalism after it was founded in 1995.
     

    

   

   

    

     Palestinian American Ahmed Moor Launches 2028 Democratic Primary Challenge Against Sen. Fetterman
    

    

     
      Nov 10, 2026
     
    

    

     
    

    

     Image Credit: Moor for Senate
    

    

     

      In Pennsylvania, the Gaza-born Palestinian American writer and businessman Ahmed Moor launched a 2028 Democratic primary challenge Monday against Senator John Fetterman, who is an ardent defender of Israel. Moor is a regular columnist at publications including The Guardian and The Nation. He’s running as a democratic socialist, connecting U.S. military aid to Israel and the Trump administration’s war on Iran to the rising cost of living. This is Ahmed Moor speaking with Democracy Now! in 2024 about his family in Gaza.
     

     

      

       
        Ahmed Moor
       
       : “My family has experienced direct loss through the genocide. Most recently, my cousin’s 19-year-old son was killed by an Israeli sniper in Rafah. And so, the urgency surrounding this lawsuit goes to the fact that the conditions are getting worse. The danger that people are exposed to continues even as we speak.”
      

     

    

   

  

  

   The original content of this program is licensed under a
   
    Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 United States License
   
   . Please attribute legal copies of this work to democracynow.org. Some of the work(s) that this program incorporates, however, may be separately licensed. For further information or additional permissions, contact us.
  

 




        

      

    
    

        

          
Ableton Live 13

        

        

          Hacker News
        

	

	  www.ableton.com
	

        

          2026-11-10 07:58:04
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  
  

   
    

     
      What’s new
     
    

    
    
     
     
    
   
  

  

   
    
    
     
     
    
   
  

  

   
    
    
     
     
    
   
  

  

   
   

    

     

      FAQs
     

    

   

   
   

    

     
    

    

     

      Ableton Live 13 adds new audio and MIDI workflows, sound design tools and mixing effects. Highlights include:
     

     
    
      
  • 
       
    
        A built-in Step Sequencer, ARA 2 support for compatible audio-editing plug-ins, Capture Automation, and Contextual Browsing for adding devices and swapping presets directly from the device chain.
       
    
      
    • 
      
  • 
       
    
        Drum Synth, new Multiband and Mid-Side Racks, expanded Rack controls, and Envelope Clips for automating and modulating effects on return tracks.
       
    
      
    • 
      
  • 
       
    
        Device Slots in the mixer, and new Core Library Drum Racks, instrument presets, Audio Effect Racks, samples, and MIDI clips.
       
    
      
    • 
      
  • 
       
    
        Arrangement Sync for Ableton Link, support for exporting tempo automation and time signature changes, and more precise event timing in exported MIDI files.
       
    
      
    • 
      
  • 
       
    
        Mixer improvements including Send sliders, a persistent Mixer Configuration menu for choosing which sections are visible, smoother mixer resizing, and an Unsolo button on the Main track, plus an updated Phaser-Flanger interface.
       
    
      
    • 
     

     

      Live 13 Suite also includes Melodyne essential, Looplet, Clipper, Transient Shaper and the Classic Dynamics & EQ Pack by Softube.
     

     

      See the full
      
       
        Release Notes
       
      
      for every change.
     

    

    

     
    

    

     

      Push 3 gains Custom Layouts, a new Step Sequencer layout, a new Performance Mixer, and Device Mode upgrades. Custom Layouts combine Session View, note areas, XYZ and mixer controls on a single page. The Step Sequencer brings the step editing experience from Live to the hardware. Device Mode adds jog wheel navigation and up to 32 Rack Macros.
     

     

      Push 2 supports the new Step Sequencer and most Device Mode improvements (except jog wheel navigation), but not Custom Layouts, Performance Mixer or Expressive Step Editing.
     

     

      See the full
      
       
        Release Notes
       
      
      for every change.
     

    

    

     
    

    

     

      Live 13 is the next major version of Ableton Live, following Live 12. It adds audio and MIDI workflows including ARA 2 support, Step Sequencer and Capture Automation, plus instruments and effects, expanded Rack controls, updated Core Library content, and more. Everything you can do in Live 12 you can still do in Live 13.
     

    

    

     
    

    

     

      Ableton Live 13 comes in three editions: Intro, Standard and Suite.
     

     

      They share the same core workflow but differ in their features and included instruments, effects and sounds. Live Intro is limited to 16 tracks and Scenes. Standard allows unlimited tracks and Scenes, and adds many more built-in instruments, effects and sounds.
     

     

      Suite includes everything in Standard plus Max for Live, the complete instrument and effect collection, and Live’s full Core Library.
     

     

      Suite also comes with Melodyne essential for ARA 2 editing, plus the Classic Dynamics & EQ Pack by Softube and Looplet as free downloads at release.
      
       
        Compare editions in detail
       
      
      .
     

    

    

     
    

    

     

      Ableton Live 13 will be released in early 2027.
      
       
        Subscribe to our Newsletter
       
      
      to be notified at release
     

    

    

     
    

    

     

      Yes, in two ways:
     

     
    
      
  • 
       
    
        If you already own Live 12 – pre-order Live 13 at 20% off.
       
    
      
    • 
      
  • 
       
    
        If you don’t own Live 12 yet – buy or upgrade to Live 12 at 20% off during the announcement offer and get the corresponding Live 13 edition free when it’s released.
       
    
      
    • 
     

    

    

     
    

    

     

      Log in to your User Account and visit the Ableton shop to see the upgrade options for your license. From now until the release of Live 13, you can buy or upgrade to Live 12 and get the corresponding Live 13 edition for free on release day.
     

    

    

     
    

    

     

      You can extend your existing plan to cover the cost of upgrading to Live 13 Suite and start using it as soon as it’s released.
      
       
        Visit the Ableton shop
       
      
      to see your upgrade options.
     

    

    

     
    

    

     

      Limited places for the Live 13 public beta are available to Live Standard and Suite owners. Learn more about the
      
       
        Ableton Live beta program
       
      
      .
     

    

    

     
    

    

     

      Most ARA 2 plug-ins work with Live 13, including Melodyne. Live 13 Suite comes with Melodyne essential. A small number have known compatibility issues. See the full
      
       
        Release Notes
       
      
      for more information.
     

     

      One ARA plug-in can be used at a time, across multiple clips and tracks.
     

    

   

   
   
  

 




        

      

    
    

        

          
Anthropic to Seek $1.3T Valuation in IPO

        

        

          Hacker News
        

	

	  www.wsj.com
	

        

          2026-11-10 07:49:32
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  Please enable JS and disable any ad blocker
 




        

      

    
    

        

          
Let over Lambda–50 Years of Lisp (2008)

        

        

          Hacker News
        

	

	  letoverlambda.com
	

        

          2026-11-10 07:35:27
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   About the Book
  

  

   
    

     
      
       
      
     
     
      

       
        Let Over Lambda
       
       (ISBN 978-1-4357-1275-1, 376+iv pp.) is one of the most
       
        hardcore
       
       computer programming books out there. Starting with the fundamentals, it describes the most advanced features of the most advanced language: C
       
        OMMON
       
       L
       
        ISP
       
       . The point of this book is to expose you to ideas that you might otherwise never be exposed to.
      

     		
    

   
  

  

   This book is about macros, that is programs that write programs. Macros are what make lisp the greatest programming language in the world. When used properly, macros enable amazing feats of abstraction, programmer productivity, and code efficiency and security that are unheard of elsewhere. Macros let you do things you simply cannot do in other languages.
  

  

   If you are looking for a dry coding manual that re-hashes common-sense techniques in whatever langue du jour, this book is not for you. This book is about pushing the boundaries of what we know about programming. While this book teaches useful macro skills that can help solve your programming problems today and now, it has also been designed to be entertaining and inspiring. If you have ever wondered what lisp or even programming itself is really about, this is the book you have been looking for.
  

  

  

   
    2026 update:
   
   Let Over Lambda was published in 2008, to align with the 50th anniversary of Lisp's invention in 1958. A lot has changed since then, in both Lisp and programming practice in general. Although my thinking and opinions have evolved since, I still believe the book holds up well as a tutorial and explanation of why Lisp so special. Going forward, the entire book is free to read online (
   
    HTML
   
   ,
   
    PDF
   
   ). Happy lisping!
  

  

  

   News
  

  
    
   
  • 
    
     Chapter 6
    
    is now open. It takes a detour through anaphoric macros and culminates in what I think is a very interesting macro:
    
     pandoric-eval
    
    .
   
    • 
   
  • 
    Official Japanese translation available at
    
     Amazon.co.jp
    
    or any other fine Japanese book store.
   
    • 
   
  • 
    
     Chapter 5
    
    now open. This is one of my favourite chapters. Enjoy.
   
    • 
   
  • 
    Added a
    
     clarifications page
    
    to better explain the Let Over Lambda message.
   
    • 
   
  • 
    Matthew Lamari wrote a review on
    
     Amazon
    
    and gave the book 5/5 stars.
   
    • 
   
  • 
    Chapter 4 has been opened. Read about it in
    
     Press Release #2
    
    .
   
    • 
   
  • 
    Adam Petersen wrote a
    
     review
    
    .
   
    • 
   
  • 
    
     Press Release #1
    
    is available. It contains summaries of all the chapters.
   
    • 
   
  • 
    
     Let Over Lambda
    
    has an ISBN: 978-1-4357-1275-1
   
    • 
   
  • 
    
     References
    
    are available in a lispy format.
   
    • 
   
  • 
    The
    
     back cover
    
    is confirmed. Thanks Leo!
   
    • 
  

 




        

      

    
    

        

          
Next-Level Benchmarking Overfitting

        

        

          Lobsters
        

	

	  databasearchitects.blogspot.com
	

        

          2026-11-10 07:20:55
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   In my
   
    recent
blog post
   
   I remarked that database benchmarking is in a crisis
because AI agents start to overfit on individual benchmarks with
questionable techniques, which drives execution times towards zero. This
has happened with
   
    TPC-D
   
   in the past, and
broke the benchmark.
   
    TPC-H
   
   tries to fight
that with rules, but most people who publish (unofficial) TPC-H results
simply ignore the rules. In combination with overly eager AI agents,
this leads to brutal overfitting.
  

  

   We are seeing the next level of that with the
   
    GenDB-V system
   
   . The
corresponding paper commands
   
    “Stop Handcrafting Your Engine!
GenDB-V: Towards AI-Generated and Formally Verified Database
Systems”
   
   , and reports speedups of 22× to 61× over Umbra and DuckDB,
and all that in a fully verified system. These are indeed impressive
claims, and would suggest that traditional database engines are in
trouble.
  

  

   Taking a step back, though, it should be clear that a performance
improvement of a factor of 22 over Umbra is infeasible, at least if we
are talking about traditional query processing. At SF10, the 22 TPC-H
queries read roughly 15GB of (compressed) base data, and on a 9950X3D
Umbra runs all queries in a total of roughly 540ms. On that machine the
memory touched for data divided by the memory bandwidth (54GB/s) alone
is about 280ms; anything below that is infeasible. Better compression
might bring that down a bit, but not by an order of magnitude.
  

  

   Unsurprisingly, the most dramatic gains of GenDB-V come from
precomputation. The agents have carefully handcrafted auxiliary data
structures for each query, which are computed at load time, and which
avoid most of the work. The physical design is heavily tuned to the
queries, too, for example, there is an extra structure that lists the
   
    supplier
   
   rows in
   
    s_acctbal DESC
   
   order, which
makes
   
    Q2
   
   trivial. Similar per-query data structures are
built for most queries. And we see that in the performance numbers:
Several queries already run in near-constant time at SF100: Q2 in 0.7
ms, Q17 in about 15 ms and Q4 in about 17 ms on one thread. That is the
TPC-D symptom, without stored aggregates.
  

  

   There is also a “plain-array” mode, which, at first glance, is more
fair, as it avoids these excessive preparations and also reports
performance improvements of just roughly a factor of 3, which seems
achievable. But when looking closely, we see that here the agents did
something even more insane: They
   
    hard-coded
   
   their knowledge about the data generator. They “know” that each customer
   
    k
   
   will be at row
   
    k-1
   
   . And they know that dbgen
numbers the
   
    i
   
   -th order
   
    32·(i/8) + i%8
   
   , so key
   
    k
   
   should be at row
   
    8·(k/32) + k%32 − 1
   
   . Which
makes the join in query
   
    Q18
   
   super cheap.
  

  

   How does all this fit together with the claim of a fully verified
database engine? Well, the code
   
    does
   
   check if the hard-coded
knowledge about the data generator holds in practice, e.g., by checking
if the guessed join partner row is correct. If not, it falls back to a
super slow generic nested loop implementation, but as that never happens
with the official TPC-H data generator, that code path is irrelevant in
the reported experiments.
  

  

   Which brings me back to my original blog post claim: Letting AI
agents optimize for a given database benchmark makes the benchmark
useless. They will do their best to find insane tricks to speed up this
particular benchmark, but none of that would work in a real system. The
high tuning and synthesis time aside, deleting a single tuple (or
inserting one in the middle) can most likely cause the whole approach to
fall off a cliff, as it forces the slow fallback path. Which is not
something you want in a production system.
  

 




        

      

    
    

        

          
What's new in the .NET 11 runtime

        

        

          Hacker News
        

	

	  learn.microsoft.com
	

        

          2026-11-10 07:20:07
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   This article describes new features in the .NET runtime for .NET 11. It was last updated for release candidate 2 (RC 2).
  

  

   Updated minimum hardware requirements
  

  

   The minimum hardware requirements for .NET 11 have been updated to require more modern instruction sets on both x86/x64 and Arm64 architectures. Additionally, the ReadyToRun (R2R) compilation targets have been updated to take advantage of newer hardware capabilities.
  

  

   Arm64 requirements
  

  

   For Apple, there's no change to the minimum hardware or the ReadyToRun target. The Apple M1 chips are approximately equivalent to
   
    armv8.5-a
   
   and provide support for at least the
   
    AdvSimd
   
   (NEON),
   
    CRC
   
   ,
   
    DOTPROD
   
   ,
   
    LSE
   
   ,
   
    RCPC
   
   ,
   
    RCPC2
   
   , and
   
    RDMA
   
   instruction sets.
  

  

   For Linux, there's no change to the minimum hardware. .NET continues to support devices such as Raspberry Pi that might only provide support for the
   
    AdvSimd
   
   instruction set. The ReadyToRun target has been updated to include the
   
    LSE
   
   instruction set, which might result in additional jitting overhead if you launch an application.
  

  

   For Windows, the baseline is updated to require the
   
    LSE
   
   instruction set. This is
   
    required by Windows 11
   
   and by
   
    all Arm64 CPUs officially supported by Windows 10
   
   . Additionally, it's inline with the Arm SBSA (Server Base System Architecture) requirements. The ReadyToRun target has been updated to be
   
    armv8.2-a + RCPC
   
   , which provides support for at least
   
    AdvSimd
   
   ,
   
    CRC
   
   ,
   
    LSE
   
   ,
   
    RCPC
   
   , and
   
    RDMA
   
   , and covers the majority of hardware officially supported.
  

  

   
    

     
      OS
     
     
      Previous JIT/AOT minimum
     
     
      New JIT/AOT minimum
     
     
      Previous R2R target
     
     
      New R2R target
     
    

   
   
    

     
      Apple
     
     
      Apple M1
     
     
      (No change)
     
     
      Apple M1
     
     
      (No change)
     
    

    

     
      Linux
     
     
      armv8.0-a
     
     
      (No change)
     
     
      armv8.0-a
     
     
      armv8.0-a + LSE
     
    

    

     
      Windows
     
     
      armv8.0-a
     
     
      armv8.0-a + LSE
     
     
      armv8.0-a
     
     
      armv8.2-a + RCPC
     
    

   
  

  

   x86/x64 requirements
  

  

   For all three operating systems (Apple, Linux, and Windows), the baseline is updated from
   
    x86-64-v1
   
   to
   
    x86-64-v2
   
   . This changes the hardware from only guaranteeing
   
    CMOV
   
   ,
   
    CX8
   
   ,
   
    SSE
   
   , and
   
    SSE2
   
   to also guaranteeing
   
    CX16
   
   ,
   
    POPCNT
   
   ,
   
    SSE3
   
   ,
   
    SSSE3
   
   ,
   
    SSE4.1
   
   , and
   
    SSE4.2
   
   . This guarantee is required by Windows 11 and by all x86/x64 CPUs officially supported on Windows 10. It includes all chips still officially supported by Intel and AMD, with the last older chips having gone out of support around 2013.
  

  

   The ReadyToRun target has been updated to
   
    x86-64-v3
   
   for Windows and Linux, which additionally includes the
   
    AVX
   
   ,
   
    AVX2
   
   ,
   
    BMI1
   
   ,
   
    BMI2
   
   ,
   
    F16C
   
   ,
   
    FMA
   
   ,
   
    LZCNT
   
   , and
   
    MOVBE
   
   instruction sets. The ReadyToRun target for Apple remains unchanged.
  

  

   
    

     
      OS
     
     
      Previous JIT/AOT minimum
     
     
      New JIT/AOT minimum
     
     
      Previous R2R target
     
     
      New R2R target
     
    

   
   
    

     
      Apple
     
     
      x86-64-v1
     
     
      x86-64-v2
     
     
      x86-64-v2
     
     
      (No change)
     
    

    

     
      Linux
     
     
      x86-64-v1
     
     
      x86-64-v2
     
     
      x86-64-v2
     
     
      x86-64-v3
     
    

    

     
      Windows
     
     
      x86-64-v1
     
     
      x86-64-v2
     
     
      x86-64-v2
     
     
      x86-64-v3
     
    

   
  

  

   Impact
  

  

   Starting with .NET 11, .NET fails to run on older hardware and might print a message similar to the following:
  

  

   

    The current CPU is missing one or more of the baseline instruction sets.
   

  

  

   For
   
    ReadyToRun
   
   -capable assemblies, there might be additional startup overhead on some supported hardware that doesn't meet the expected support for a typical device.
  

  

   Reason for change
  

  

   .NET supports a broad range of hardware, often above and beyond the minimum hardware requirements put in place by the underlying operating system. This support adds significant complexity to the codebase, particularly for much older hardware that's unlikely to still be in use. Additionally, it defines a "lowest common denominator" that AOT targets must default to, which can, in some scenarios, lead to reduced performance.
  

  

   The update to the minimum baseline was made to reduce the maintenance complexity of the codebase and to better align with the documented (and often enforced) hardware requirements of the underlying operating system.
  

  

   For more information, see
   
    Minimum hardware requirements updated
   
   .
  

  

   Runtime Async
  

  

   .NET 11 introduces runtime-native async (Runtime Async V2), a significant step toward replacing compiler-generated async state machines with runtime-managed suspension and resumption. Instead of the compiler emitting state-machine classes, the runtime itself tracks async execution, producing cleaner stack traces, better debuggability, and lower overhead.
  

  

   Runtime Async is a preview feature. To opt in, add the following property to your project file:
  

  
<PropertyGroup>
  <Features>runtime-async=on</Features>
</PropertyGroup>


  

   A
   
    net11.0
   
   project no longer requires
   
    <EnablePreviewFeatures>true</EnablePreviewFeatures>
   
   to use Runtime Async.
  

  

   The .NET runtime libraries themselves are compiled with
   
    runtime-async=on
   
   . The runtime libraries no longer contain compiler-generated state machines and rely entirely on runtime-provided async. This makes it possible to migrate an entire app (with only library dependencies) to the new model, and it provides broad functional and performance validation of the feature. The product team welcomes any reports—positive or negative—about throughput and library size changes you observe.
  

  

   .NET 11 also includes two additional improvements:
  

  
    
   
  • 
    
     Covariant
     
      Task
     
     →
     
      Task<T>
     
     overrides:
    
    When a derived class returns
    
     Task<T>
    
    for a base method that returns
    
     Task
    
    , the runtime now generates a void-returning thunk that bridges the calling convention difference, so virtual dispatch works for both flavors. The same fix applies to NativeAOT.
   
    • 
   
  • 
    
     Inlining in crossgen2:
    
    Restrictions that prevented runtime-async methods from being inlined during ReadyToRun (R2R) compilation have been removed. All async tests pass with both crossgen2 and composite R2R, and inlining of await-less async calls (the synchronous fast path) is confirmed end-to-end.
   
    • 
  

  

   

    Note
   

   

    The
    
     DOTNET_RuntimeAsync
    
    and
    
     UNSUPPORTED_RuntimeAsync
    
    environment variables that previously controlled runtime-async behavior have been removed. To opt out of runtime-async per project, set
    
     <UseRuntimeAsync>false</UseRuntimeAsync>
    
    in your project file instead of relying on the environment variable.
   

  

  

   Cleaner live stack traces
  

  

   The most visible improvement is in
   
    live stack traces
   
   —what profilers, debuggers, and
   
    new StackTrace()
   
   see during execution. With compiler-generated async, each async method produces multiple frames from state-machine infrastructure. With Runtime Async, the actual methods appear directly on the call stack.
  

  
// To enable runtime async, add the following to your .csproj:
//   <Features>runtime-async=on</Features>

await OuterAsync();

static async Task OuterAsync()
{
    await Task.CompletedTask;
    await MiddleAsync();
}

static async Task MiddleAsync()
{
    await Task.CompletedTask;
    await InnerAsync();
}

static async Task InnerAsync()
{
    await Task.CompletedTask;
    Console.WriteLine(new StackTrace(fNeedFileInfo: true));
}


  

   
    Without
    
     runtime-async
    
    —13 frames, state-machine infrastructure visible:
   
  

  
   at Program.<<Main>$>g__InnerAsync|0_2() in Program.cs:line 24
   at System.Runtime.CompilerServices.AsyncMethodBuilderCore.Start[TStateMachine](...)
   at Program.<<Main>$>g__InnerAsync|0_2()
   at Program.<<Main>$>g__MiddleAsync|0_1() in Program.cs:line 14
   at System.Runtime.CompilerServices.AsyncMethodBuilderCore.Start[TStateMachine](...)
   at Program.<<Main>$>g__MiddleAsync|0_1()
   at Program.<<Main>$>g__OuterAsync|0_0() in Program.cs:line 8
   at System.Runtime.CompilerServices.AsyncMethodBuilderCore.Start[TStateMachine](...)
   at Program.<<Main>$>g__OuterAsync|0_0()
   at Program.<Main>$(String[] args) in Program.cs:line 3
   at System.Runtime.CompilerServices.AsyncMethodBuilderCore.Start[TStateMachine](...)
   at Program.<Main>$(String[] args)
   at Program.<Main>(String[] args)


  

   
    With
    
     runtime-async
    
    —5 frames, the real call chain:
   
  

  
   at Program.<<Main>$>g__InnerAsync|0_2() in Program.cs:line 24
   at Program.<<Main>$>g__MiddleAsync|0_1() in Program.cs:line 14
   at Program.<<Main>$>g__OuterAsync|0_0() in Program.cs:line 8
   at Program.<Main>$(String[] args) in Program.cs:line 3
   at Program.<Main>(String[] args)


  

   

    Note
   

   

    Exception stack traces (from
    
     catch (Exception ex)
    
    ) already look the same with or without Runtime Async, because existing
    
     ExceptionDispatchInfo
    
    cleanup in compiler-generated code handles that case. The improvement is in what you see
    
     during
    
    live execution.
   

  

  

   This improvement benefits anything that inspects the live execution stack, including profiling tools, diagnostic logging, and the debugger call stack window.
  

  

   NativeAOT and ReadyToRun support
  

  

   Runtime Async supports NativeAOT and ReadyToRun compilation. This extends the feature beyond JIT-compiled code to ahead-of-time compiled scenarios. The runtime also reuses continuation objects more aggressively and avoids saving unchanged locals, reducing allocation pressure in async-heavy code.
  

  

   Debugging improvements
  

  

   Breakpoints now bind correctly inside runtime-async methods, and the debugger can step through
   
    await
   
   boundaries without jumping into compiler-generated infrastructure.
  

  

   Runtime Async performance improvements
  

  

   Runtime Async includes several performance improvements:
  

  
    
   
  • 
    
     JIT async support:
    
    The JIT compiles a dedicated runtime-async version of a synchronous, task-returning method rather than delegating through a thunk. The JIT turns the method's tail calls into runtime-async calls and awaits the task that would otherwise be returned, eliminating an extra layer of indirection.
   
    • 
   
  • 
    
     Tail-merged suspension points:
    
    The JIT tail-merges async suspension points so generated code is smaller.
   
    • 
   
  • 
    
     Cached continuations:
    
    Continuations used for runtime-async callable task thunks are cached and reused.
   
    • 
   
  • 
    
     Pooled methods opt out:
    
    Methods that are already pooled opt out of runtime-async, avoiding redundant work.
   
    • 
   
  • 
    
     Tiered async compilation:
    
    Async versions now flow through tiered compilation, so hot async methods get tier 1 optimizations after warm-up.
   
    • 
   
  • 
    
     Task and ValueTask factory intrinsics:
    
    The JIT recognizes common factories, such as
    
     Task.FromResult
    
    ,
    
     Task.CompletedTask
    
    , and
    
     ValueTask.FromResult
    
    , and folds them into faster async paths.
   
    • 
   
  • 
    
     Tail-await optimizations:
    
    Implicit tailcalls from async methods are enabled again when the method directly returns another async result, and
    
     await Task.Yield()
    
    avoids extra allocations in runtime-async paths.
   
    • 
  

  

   Async continuations without ExecutionContext
  

  

   Async continuations can now opt out of
   
    ExecutionContext
   
   capture and restore.
   
    ExecutionContext
   
   carries ambient state—such as
   
    AsyncLocal<T>
   
   values—across
   
    await
   
   points. Every
   
    Task
   
   continuation previously captured a snapshot of the context and restored it before running, even when no
   
    AsyncLocal<T>
   
   state was in use and the restore was a no-op.
  

  

   The runtime now detects when a continuation has nothing to restore and skips the capture/restore cycle entirely.
   
    Task
   
   ,
   
    Task<T>
   
   ,
   
    ValueTask
   
   , and
   
    ValueTask<T>
   
   all benefit from this change, as does the runtime-async implementation path. Applications that use
   
    ConfigureAwait(false)
   
   and
   
    AsyncLocal<T>
   
   sparingly see reduced overhead in high-throughput async code paths.
  

  

   JIT improvements
  

  
    
   
  • 
    
     Bounds check elimination:
    
    The just-in-time (JIT) compiler now eliminates bounds checks for the common pattern where an index plus a constant is compared against a length, such as
    
     i + cns < len
    
    . It also eliminates more redundant bounds checks for index-from-end access (for example,
    
     values[^1]
    
    ). These improvements reduce redundant checks in tight loops and improve throughput for array and span operations.
   
    • 
   
  • 
    
     Redundant checked context removal:
    
    The JIT can now prove and remove redundant checked arithmetic contexts—for example, when a value is already known to be in range. This optimization eliminates unnecessary overflow checks in generated code.
   
    • 
   
  • 
    
     Switch expression folding:
    
    Multi-target
    
     switch
    
    expressions now fold into simpler branchless checks when the targets are a small set of constants, for example
    
     x is 0 or 1 or 2 or 3 or 4
    
    .
   
    • 
   
  • 
    
     Faster uint-to-float/double casts:
    
    Casting
    
     uint
    
    to
    
     float
    
    or
    
     double
    
    is faster on pre-AVX-512 x86 hardware.
   
    • 
   
  • 
    
     SVE2 intrinsics:
    
    New Arm SVE2 (Scalable Vector Extension 2) intrinsics are available:
    
     ShiftRightLogicalNarrowingSaturate(Even|Odd)
    
    . These expand the set of vectorized operations available on Arm hardware that supports SVE2.
   
    • 
   
  • 
    
     
      Math.BigMul
     
     on x64:
    
    
     Math.BigMul(long, long, out long)
    
    is now significantly faster on x64. The JIT generates a single
    
     MUL r/m64
    
    instruction when both operands are 64-bit values and the caller requests the high half of the result, eliminating the previous helper call.
   
    • 
   
  • 
    
     Single-IG prolog restriction removed:
    
    The JIT no longer requires the function prolog to fit in a single instruction group (IG). Complex prologues with many saved registers, large stack allocations, or runtime-async state setup no longer trigger fallback paths.
   
    • 
   
  • 
    
     
      SELECT(cond, cns, cns)
     
     folding:
    
    The JIT now folds conditional selects whose two branches both produce the same constant into just that constant—for example,
    
     condition ? 42 : 42
    
    becomes
    
     42
    
    . This fold eliminates unnecessary comparisons that can appear after earlier optimizations unify branches.
   
    • 
   
  • 
    
     AVX-VNNI-512 intrinsics:
    
    
     System.Runtime.Intrinsics.X86.AvxVnni.V512
    
    exposes 512-bit forms of the
    
     AVX-VNNI
    
    multiply-add intrinsics on CPUs with
    
     AVX512-VNNI
    
    support.
   
    • 
   
  • 
    
     Saturating floating-point conversions:
    
    Unchecked
    
     float
    
    and
    
     double
    
    conversions to small integer types now saturate to type bounds instead of wrapping through intermediate truncation.
   
    • 
   
  • 
    
     ARM64
     
      Vector<T>
     
     by reference for SVE:
    
    When the runtime is compiled with ARM SVE support,
    
     Vector<T>
    
    values are passed by reference rather than by value, aligning with the ARM calling convention for scalable types and enabling better code generation for SVE-intensive code.
   
    • 
  

  

   For better performance and code quality, .NET 11 adds several more JIT optimizations:
  

  

   Constant-folding SequenceEqual
  

  

   The JIT can now fold a
   
    string.Equals
   
   or
   
    ReadOnlySpan<T>.SequenceEqual
   
   call whose operands are both compile-time constants, replacing the byte-by-byte comparison with the constant
   
    true
   
   or
   
    false
   
   result. This matters most after inlining, when a caller passes another literal to a helper that compares against a known string. When
   
    IsAdmin
   
   is inlined into a caller that passes
   
    "Guest"
   
   , the JIT sees
   
    "Guest" == "Admin"
   
   and folds it to
   
    false
   
   :
  

  
static bool IsAdmin(string role) => role == "Admin";


  

   The optimization applies to string literals,
   
    const string
   
   fields, and UTF-8 literals (for example,
   
    "PNG"u8
   
   ).
  

  

   Devirtualization improvements
  

  

   The JIT can now devirtualize generic virtual methods, including non-shared generic virtual methods and shared generic virtual methods that don't require a runtime lookup. Default interface methods declared on generic interfaces can now be devirtualized as well.
  

  

   In addition, the result of
   
    Activator.CreateInstance<T>()
   
   is now treated as having an exact type, allowing the JIT to devirtualize subsequent calls made on the returned object.
  

  

   These improvements unlock further downstream optimizations such as inlining and constant folding, reducing runtime dispatch overhead and improving performance. For example:
  

  
IfaceGeneric<string> caller = new Caller<string>();
Iface obj = Activator.CreateInstance<Impl>();
caller.DefaultImpl(obj, "test"); // Can be optimized down to Console.WriteLine("test")

interface Iface
{
    void GenericMethod<T>(T value);
}

interface IfaceGeneric<T>
{
    void DefaultImpl(Iface obj, T value) => obj.GenericMethod(value);
}

class Impl : Iface
{
    public void GenericMethod<T>(T value) => Console.WriteLine(value);
}

class Caller<T> : IfaceGeneric<T>
{
}


  

   Here the JIT can determine the exact implementation behind both interface calls, devirtualize them, inline through the call chain, and ultimately fold the code down to the equivalent of
   
    Console.WriteLine("test")
   
   .
  

  

   Eliminating bounds checks after an empty-span guard
  

  

   The JIT now picks up the
   
    length != 0
   
   assertion from an empty-span check and uses it to prove the bounds check on the first element succeeds:
  

  
if (!span.IsEmpty && span[0] == value)
{
    // The bounds check on span[0] is now eliminated.
}


  

   Redundant branch and test elimination
  

  

   When an outer predicate is already implied by an inner branch, the JIT now removes the redundant outer check. Similarly, when code assigns a value in a conditional and then immediately tests it, the second test is eliminated:
  

  
if (x > 0)
{
    if (x > 1) S();  // The outer x > 0 check is folded away.
}

int y = condition ? 1 : 2;
if (y == 1) A(); else B();  // The y == 1 test is eliminated;
                             // each branch of the ternary goes directly to A() or B().


  

   These optimizations are most visible after inlining, where guards from different methods land in the same compiled body.
  

  

   Hardware intrinsics and code generation
  

  

   .NET 11 includes several new hardware intrinsics and code generation improvements:
  

  
    
   
  • 
    
     Hardware FP16 instructions for
     
      Half
     
     arithmetic and conversions:
    
    The JIT uses hardware FP16 instructions for
    
     Half
    
    arithmetic and conversions when the processor supports them. On x64, arithmetic uses AVX10.1, while conversions between
    
     Half
    
    and
    
     float
    
    can use F16C (available on most AVX2-capable hardware). On Arm64, arithmetic uses the optional FP16 instruction set, while conversions between
    
     Half
    
    and
    
     float
    
    or
    
     double
    
    use baseline Arm64 instructions. The optimization requires no application changes and preserves the existing ABI representation of
    
     Half
    
    .
   
    • 
   
  • 
    
     Better cost modeling for x86/x64 SIMD:
    
    The JIT's floating-point execution and size costs previously reflected x87-era assumptions. Updated costs that reflect modern SSE/AVX hardware let the JIT make better decisions about hoisting and common subexpression elimination (CSE) around SIMD code.
   
    • 
   
  • 
    
     Faster
     
      DotProduct
     
     on AVX:
    
    Lowering for
    
     Vector128.Dot
    
    -style operations now emits a
    
     mul + permute + add
    
    sequence instead of
    
     vdpps
    
    /
    
     vdppd
    
    when AVX is available, which is consistently faster.
   
    • 
   
  • 
    
     Faster
     
      IndexOfAnyAsciiSearcher
     
     on Arm64:
    
    Arm64 versions of
    
     Vector*.Count
    
    ,
    
     IndexOf
    
    , and
    
     LastIndexOf
    
    no longer route through
    
     ExtractMostSignificantBits
    
    , yielding a 5–50% improvement in workloads that use these APIs in their core loop.
   
    • 
   
  • 
    
     Arm64
     
      ToScalar
     
     for 64-bit integers:
    
    
     ToScalar
    
    on
    
     Vector*<long>
    
    and
    
     Vector*<ulong>
    
    now uses
    
     fmov
    
    instead of
    
     umov
    
    , which is shorter and faster on most cores.
   
    • 
   
  • 
    
     SVE
     
      CreateWhile
     
     API expansion:
    
    
     CreateWhile
    
    gains signed,
    
     double
    
    , and
    
     single
    
    variants alongside the existing unsigned ones, completing the predicate-generation surface for SVE loops.
   
    • 
   
  • 
    
     New SVE2 and Arm64 instruction-set detection:
    
    The runtime now reports
    
     SVE_AES
    
    ,
    
     SVE_SHA3
    
    ,
    
     SVE_SM4
    
    ,
    
     SHA3
    
    , and
    
     SM4
    
    as separate instruction sets, allowing
    
     Sve2*.IsSupported
    
    queries for those features on capable hardware.
   
    • 
   
  • 
    
     AVX10 detection fix:
    
    The CPUID-bit cache for AVX10 was being overwritten by a later query, which could cause AVX10 to be misreported on capable hardware. This is now fixed.
   
    • 
  

  

   ReadyToRun improvements
  

  

   
    Comparer<T>.Default
   
   and
   
    EqualityComparer<T>.Default
   
   are now specialized in ReadyToRun (R2R) images. Previously, the default comparers used reflection that R2R couldn't see ahead of time, causing callers to fall back to the JIT. R2R now generates a specialized helper in the image—mirroring the NativeAOT approach—and benchmarks show up to a 20× improvement for collections operations that rely on the default comparer.
  

  

   VM improvements
  

  
    
   
  • 
    
     Cached interface dispatch on non-JIT platforms:
    
    On platforms that lack JIT support, such as iOS, interface dispatch was falling back to an expensive generic fixup path. Cached dispatch yields up to 200x improvements in interface-heavy code on these targets.
   
    • 
   
  • 
    
     
      Guid.NewGuid()
     
     on Linux:
    
    
     Guid.NewGuid()
    
    on Linux now uses the
    
     getrandom()
    
    syscall with batch caching instead of reading from
    
     /dev/urandom
    
    , yielding approximately 12% throughput improvement for GUID generation.
   
    • 
  

  

   WebAssembly improvements
  

  

   Browser and WebAssembly support has several improvements:
  

  
    
   
  • 
    
     WebCIL payload loading:
    
    The runtime can now load WebCIL payloads directly, improving compatibility with browser-based deployment scenarios.
   
    • 
   
  • 
    
     Better debugging symbols:
    
    Symbol and stack trace quality for WebAssembly debugging has improved, making it easier to diagnose issues in browser-hosted .NET apps.
   
    • 
   
  • 
    
     
      float[]
     
     ,
     
      Span<float>
     
     , and
     
      ArraySegment<float>
     
     marshaling:
    
    
     float[]
    
    ,
    
     Span<float>
    
    , and
    
     ArraySegment<float>
    
    are now marshaled more directly across JavaScript boundaries, reducing overhead for interop-heavy code.
   
    • 
  

  

   .NET includes improvements to CoreCLR-on-WebAssembly:
  

  
    
   
  • 
    
     WebCIL V1 is the default for CoreCLR WASM builds:
    
    The shared WebCIL header gains a
    
     TableBase
    
    field (28 → 32 bytes). Both Mono and CoreCLR readers accept V0 and V1. Crossgen2's
    
     WasmObjectWriter
    
    produces V1 directly, and CoreCLR-flavored WASM SDK builds default
    
     WasmWebcilVersion
    
    to
    
     V1
    
    .
   
    • 
   
  • 
    
     Native re-link works for CoreCLR WASM apps:
    
    A full Emscripten-based pipeline replaces the previous stub targets. Re-linking
    
     dotnet.native.wasm
    
    from the runtime pack and including custom native code via
    
     NativeFileReference
    
    now works.
   
    • 
   
  • 
    
     JavaScript minification in Release builds:
    
    Browser CoreCLR Release builds ship minified JavaScript.
   
    • 
   
  • 
    
     NativeAOT publish for WASM no longer drops package satellites:
    
    Satellite assemblies from NuGet packages are now passed to ILC and pruned from the publish output, fixing localization for AOT-published apps that depend on packages such as
    
     System.CommandLine
    
    .
   
    • 
  

  

   CoreCLR on WebAssembly now runs the libraries test suite end to end.
  

  

   Platform support for more than 1024 CPUs
  

  

   The .NET runtime can now initialize on machines with more than 1024 logical processors. Previously,
   
    sched_getaffinity
   
   was called with the default
   
    cpu_set_t
   
   (capped at 1024), causing initialization to fail on high-core-count servers. The runtime now allocates the CPU set dynamically. The GC retains its 1024-heap limit, but the CPU count limit is removed.
  

  

   In-process crash report logging
  

  

   A new in-process crash reporting mechanism captures diagnostic information from within the crashing process before it terminates. Previously, crash diagnostics were collected by an out-of-process monitor. While the out-of-process approach is safe, it can miss information that's only available inside the dying process. The new in-process path logs the managed stack trace, module list, and key runtime state to a well-known path before the process exits.
  

  

   This capability originated on mobile platforms and is now also available on Linux and macOS. When
   
    DOTNET_DbgEnableMiniDump
   
   isn't enabled, set
   
    DOTNET_EnableCrashReport=1
   
   or
   
    DOTNET_EnableCrashReportOnly=1
   
   to select the in-process reporter. Existing
   
    createdump
   
   behavior remains in place when minidumps are enabled.
  

  

   NativeAOT: faster interface dispatch
  

  

   NativeAOT now uses a dispatch helper for interface method calls. Instead of a direct fat-pointer call sequence, the runtime routes interface dispatch through a shared helper that can be patched to the correct implementation after the call site warms up. This reduces the binary size of interface call sites and improves throughput on workloads with many interface method calls.
  

  

   Generic virtual method dispatch also uses the shared dispatch-cell infrastructure, which improves both monomorphic and polymorphic call performance. In addition,
   
    Assembly.GetCallingAssembly()
   
   now works on NativeAOT when stack trace data is available.
  

  

   SIMD lane construction and composition
  

  

   
    System.Runtime.Intrinsics
   
   now includes lane construction and composition APIs for hardware vector types. The new APIs let you construct a vector from individually specified lanes and extract or reorder lanes between vectors. This enables precise, portable control over SIMD vector element placement without falling back to platform-specific intrinsics.
  

  

   The new methods fall into a few families:
  

  
    
   
  • 
    
     Patterned construction:
    
    
     CreateGeometricSequence
    
    ,
    
     CreateAlternatingSequence
    
    , and
    
     CreateHarmonicSequence
    
    build a vector from a starting value and a rule.
   
    • 
   
  • 
    
     Interleave and de-interleave:
    
    
     Zip
    
    ,
    
     ZipLower
    
    /
    
     ZipUpper
    
    ,
    
     Unzip
    
    ,
    
     UnzipEven
    
    /
    
     UnzipOdd
    
    .
   
    • 
   
  • 
    
     Rearrange:
    
    The
    
     Concat
    
    family (
    
     ConcatLowerLower
    
    ,
    
     ConcatLowerUpper
    
    ,
    
     ConcatUpperLower
    
    ,
    
     ConcatUpperUpper
    
    ) and
    
     Reverse
    
    .
   
    • 
  

  
using System.Runtime.Intrinsics;

// {1, 2, 4, 8} — each lane is the previous lane times two
Vector128<int> powers = Vector128.CreateGeometricSequence(1, 2);

// Interleave two vectors lane-by-lane
(Vector128<int> lower, Vector128<int> upper) =
    Vector128.Zip(Vector128.Create(1), Vector128.Create(2));


  

   These APIs are available on
   
    Vector128<T>
   
   ,
   
    Vector256<T>
   
   ,
   
    Vector512<T>
   
   ,
   
    Vector64<T>
   
   , and
   
    Vector<T>
   
   . They're building blocks for image processing, audio digital signal processing (DSP), and other SIMD-intensive workloads that need fine-grained control over vector element layout.
  

  

   File locking on iOS and tvOS
  

  

   On iOS and tvOS, including simulators, CoreCLR now disables advisory file locking by default. A
   
    FileStream
   
   that acquired an advisory lock could cause the operating system to terminate an app when the app entered the background while it held the lock. As a result,
   
    FileShare
   
   restrictions are no longer enforced by those locks on iOS and tvOS, including between handles in the same process. Mac Catalyst and other platforms keep their existing defaults.
  

  

   If your app relies on
   
    FileShare
   
   enforcement and you accept the risk of suspension-related termination, restore file locking by using either of the following settings:
  

  
    
   
  • 
    
    
     Set the
     
      DOTNET_SYSTEM_IO_DISABLEFILELOCKING
     
     environment variable to
     
      0
     
     .
    
    
   
    • 
   
  • 
    
    
     Set the
     
      System.IO.DisableFileLocking
     
     runtime configuration property to
     
      false
     
     . For example, in the
     
      runtimeconfig.json
     
     file:
    
    
    
    {
  "configProperties": {
    "System.IO.DisableFileLocking": false
  }
}

    
   
    • 
  

  

   Reliability fixes
  

  

   The runtime includes fixes for the following issues:
  

  
    
   
  • 
    On Linux, the SDK no longer crashes on Red Hat Enterprise Linux (RHEL) 8 on Arm64, and the runtime correctly traverses cgroup v2 memory limits at the root of the hierarchy.
   
    • 
   
  • 
    Generic virtual method dispatch no longer hangs after repeated
    
     AssemblyLoadContext
    
    unloads.
   
    • 
   
  • 
    
     TryDequeue
    
    no longer spuriously reports an empty queue while a segment freezes during growth.
    
     TryPeek
    
    has the same reliability fix.
   
    • 
   
  • 
    On Windows, garbage collection works correctly on machines with multiple CPU groups.
   
    • 
  

  

   Runtime diagnostics
  

  

   The async profiler now instruments both runtime-async methods and compiler-generated async state-machine methods, so tools receive one consistent event model regardless of async implementation style. The runtime also adds improved interpreter perf-map logging support, and fixes parsing of
   
    CORECLR_NOTIFICATION_PROFILERS
   
   lists that don't end with a semicolon.
  

  

   See also
  

  
 




        

      

    
    

        

          
AlphaProof Code

        

        

          Hacker News
        

	

	  deepmind.google
	

        

          2026-11-10 07:11:12
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   

    
     November 10, 2026
    
    
     Research
    
   

  

  

   

    How Google DeepMind researchers built a new agentic framework that formally verified the code of Signal’s cryptographic protocol — long considered to be a grand security challenge
   

   

    Today, we’re sharing a milestone in software security long considered to be a grand security challenge: Google DeepMind researchers guided AI agents to mathematically prove key security properties of the actual code underlying the Signal protocol, the technology that protects billions of private conversations in apps like Signal and Google Messages.
   

   

    This breakthrough discovery was made using
    
     AlphaProof Code
    
    ,
    
     a novel agentic framework for formal verification at unprecedented depth that combines human expertise with AI agents.
    
    Formal verification—mathematically proving code runs correctly without flaws—is the highest standard of security assurance; however, it is difficult and often labor-intensive.
   

   

    Our work marks the first time AI has been used to formally verify a widely deployed cryptographic protocol at this depth. It's also the first time the implementation of a widely deployed protocol like this has been formally verified by any method, with or without AI.
   

   

    How we verified Signal
   

   

    AlphaProof Code is a multi-LLM agentic framework that splits the work of formal verification the way a research team would: human experts work with AI to decide
    
     what
    
    to prove, and a group of AI agents does it.
   

   

    First, our researchers collaborated with a mix of models to translate Signal’s security goals into formal mathematical specifications, with human experts reviewing every one. From there, agents powered by
    
     Gemini Carbon
    
    did the proofs, generating over six million lines of Lean, a computer language that mathematically proves the accuracy of code.
   

   

    Next, the agents audited the proof and highlighted areas that needed a second look by a human – just one percent of the codebase, a massive time savings. Because Lean automatically checks the rest, our experts could focus their review where human judgment matters most.
   

   

    Cryptographic protocols underpin nearly all digital communication, from online banking to web browsing, and a single flaw can expose millions of people at once. That's why experts have spent decades formally analyzing them.
   

   

    But most protocol verification stops at the design level. Our agents went further, proving that the compiled code fulfills the key security properties – such as keeping messages protected before and after a device is temporarily compromised – down to the exact code running on devices. Because real-world vulnerabilities often hide in the gap between design and implementation, bridging this gap makes these proofs vastly more complex.
   

   

    Even at this complexity, our verification process took just four weeks – a task that historically takes expert teams years – proving that Signal's core cryptographic code delivers the security protections our experts specified.
   

   

    To confirm that AlphaProof Code can tell correct code from buggy code, we reintroduced two real, previously fixed bugs into an isolated version of Signal's code. In both cases, the system produced a machine-checked proof that the buggy version was insecure.
   

  

  

   

    

     

      
       In AlphaProof Code, AI agents help users write a specification, then autonomously prove that the implementation meets it. Every proof is checked by Lean to verify the agents' work.
      
     

    

   

  

  

   

    While prior formal verification work has necessarily focused on smaller scopes, this new approach enables a significant expansion. Traditionally, verifying that production code strictly matches its cryptographic design required extensive manual effort, making the use of AI agents to automatically translate live code into valid Lean theorems a great breakthrough. As AI-driven security threats grow, having the core Signal protocol rigorously verified with automated theorem proving gives us even greater confidence that our code delivers on its privacy guarantees.
   

   

    The future of security
   

   

    Achieving this long-standing challenge demonstrates how AI can bring elite security assurance to businesses, governments, and critical infrastructure, helping defend against agent-driven cyber threats.
   

   

    Verifying Signal's core cryptography lays the groundwork to secure other vital systems, from medical device firmware to power grid software.
   

   

    Scaling these techniques requires continued research. Paired with automated defense agents like
    
     CodeMender
    
    , formal verification can help counter the speed and scale of modern cyber threats to create software with mathematical proof that its protections work.
   

   

    We are open-sourcing our
    
     formal verification artifacts
    
    for community use. Read the technical paper below.
   

  

  

   

    Acknowledgements
   

   

    This research was developed by Swarat Chaudhuri, Andrew Ferraiuolo, Anton Kovsharov, Tej Chajed, Sam Schlesinger, Karn Seth, Jonathan Katz, Charles Sutton, and Pushmeet Kohli.
   

   

    We thank Eric Wieser for help with open-sourcing our code, Owen Jones for program management support, and Martín Abadi, Christopher Henson, Katerina Hristova, Henryk Michalewski, Jonathan Protzenko and George Tsoukalas for helpful discussions. We thank Signal's Rolfe Schmidt, Michael Rosenberg, and Ehren Kret for their feedback on our methodology. We also thank Tulsee Doshi, Four Flynn, Kate Olszewska, Alicia Huang, Andy Liu, Benoit Schillings, Raluca Ada Popa, Melvin Johnson, Koray Kavukcuoglu, Demis Hassabis, and Sundar Pichai for their support of the project.
   

  

  

   

    

     

      

       Introducing CodeMender: an AI agent for code security
      

     

    

   

   

    

     

      

       Proactive cyber defense for governments and enterprises
      

     

    

    

     

      

       Gemini 4 Carbon: Our next frontier model
      

     

    

    

     

      

       AI achieves silver-medal standard solving International Mathematical Olympiad problems
      

     

    

   

  

 




        

      

    
    

        

          
SAP patches ICM2SHELL and PROXYGATE maximum severity flaws

        

        

          Bleeping Computer
        

	

	  www.bleepingcomputer.com
	

        

          2026-11-10 07:07:03
        

        

          
            

          
          

            SAP patched 35 vulnerabilities in its November 2026 security updates, including four maximum-severity issues affecting its NetWeaver, Web Dispatcher, and Gateway software. [...]...
          

        

        

          
Original Article

          

 

  

   SAP
  

  

   SAP patched 35 vulnerabilities in its
   
    November 2026 security updates
   
   , including four maximum-severity issues affecting its NetWeaver, Web Dispatcher, and Gateway software.
  

  

   The company addressed memory corruption (
   
    CVE-2026-76964
   
   ) and missing authentication (
   
    CVE-2026-120017
   
   ) flaws in the NetWeaver Application Server ABAP's Internet Communication Manager and SAML2 Service Provider components.
  

  

   NetWeaver is the core app platform that underpins SAP's business software and handles application integration, authentication, user management, and data processing.
  

  

   
    image
   
  

  

   The other two maximum severity vulnerabilities stem from a broken access control weakness (
   
    CVE-2026-89103
   
   ) in SAP Gateway and a memory corruption issue (
   
    CVE-2026-89126
   
   ) in SAP Web Dispatcher.
  

  

   Gateway is a core framework that enables external apps to securely connect to SAP backend systems, while Web Dispatcher (deployed in almost every enterprise SAP environment) is a specialized component that acts as a load balancer and reverse proxy for web requests entering an SAP system architecture.
  

  

   Cybersecurity firm Onapsis, which found and reported three of these security issues, collectively tracks CVE-2026-76964 and CVE-2026-89126 as
   
    ICM2SHELL
   
   and the CVE-2026-89103 pre-auth remote code execution vulnerability as
   
    PROXYGATE
   
   .
  

  

   "ICM2SHELL turns a routine part of web traffic into a point of ingress for attackers. [..] The result is remote code execution against the component that faces the network by design: no SAP user, no password and no user interaction," Onapsis said.
  

  

   "PROXYGATE works by convincing the SAP Gateway that an unauthenticated, external attacker is one of the internal application servers. [..] There is no SAP user, no password, and no user interaction, yet full control of the SAP system as the account that owns the installation is achieved. On a production ERP system, that means direct exposure of the business data, transaction integrity, and the availability of critical business applications."
  

  

   SAP rated these four vulnerabilities 10/10 on the CVSS severity scale, stating that unauthenticated attackers can exploit them to fully compromise the targeted systems remotely.
  

  

   More recently patched max severity SAP security issues
  

  

   These are the latest in a string of other maximum-severity flaws SAP has fixed in multiple components in recent months.
  

  

   For instance, it patched
   
    CVE-2026-58231
   
   in the Commerce Cloud cloud-based e-commerce platform in August, which threat intelligence firm Defused
   
    flagged as actively exploited in attacks
   
   days after the patch.
  

  

   It also addressed two more max severity flaws in
   
    September
   
   and
   
    October
   
   : a memory corruption flaw in the SAP Kernel code (tracked as CVE-2026-44756 and dubbed
   
    OVERPASS
   
   by Onapsis security researchers who reported it) and an OAuth2 SSRF vulnerability affecting multi-tenant BTP applications (CVE-2026-89111).
  

  

   The US Cybersecurity and Infrastructure Security Agency (CISA)
   
    has flagged 14 SAP security flaws
   
   as actively exploited since November 2021, three of which ransomware groups also abused in the wild.
  

  

   SAP is a German multinational software company that reported revenues exceeding €36 billion in fiscal year 2025 and serves 99 of the 100 largest companies worldwide.
  

  

   

    
     article image
    
   

   

    

     
      Uncover email threats your existing defenses may miss.
     
    

    

     Adaptive Security's AI agents analyze email intent, context, and behavior to uncover phishing, business email compromise, and invoice fraud.
    

    

     See what's getting through with a 14-day read-only scan of Microsoft 365 or Google Workspace, with no MX changes.
    

    

     
      Start your free email security scan.
     
    

   

  

 




        

      

    
    

        

          
New OpenSSH Vulnerability

        

        

          Schneier
        

	

	  www.schneier.com
	

        

          2026-11-10 07:02:38
        

        

          
          

            It’s a bad one, and it’s been in the code for a decade:
A newly disclosed flaw involving OpenSSH and musl, dubbed “*sshole,” allows attackers to log in to certain Alpine Linux and other musl-based Linux accounts configured to block password authentication simply by entering a...
          

        

        

          
Original Article

          

 

  

   

    It’s a
    
     bad one
    
    , and it’s been in the code for a decade:
   

   

    

     A newly disclosed flaw involving OpenSSH and musl, dubbed “*sshole,” allows attackers to log in to certain Alpine Linux and other musl-based Linux accounts configured to block password authentication simply by entering an oversized password.
    

   

   

    “Oversized” means longer than 256 bytes.
    
     Details
    
    .
   

   

    Slashdot
    
     thread
    
    . And another news
    
     article
    
    .
   

   

    
     Tags:
     
     ,
     
     ,
     
     ,
     
    
   

   

    
     Posted on November 10, 2026 at 7:02 AM
    
    •
    
     0 Comments
    
   

  

 

 

  Sidebar photo of Bruce Schneier by Joe MacInnis.
 




        

      

    
    

        

          
Show HN: A 15 MB self-hosted Netflix and Spotify for your media server

        

        

          Hacker News
        

	

	  github.com
	

        

          2026-11-10 06:51:19
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   

    
     English
    
    ·
    
     简体中文
    
    ·
    
     हिन्दी
    
    ·
    
     Español
    
    ·
    
     Français
    
    ·
    
     العربية
    
    ·
    
     Português
    
    ·
    
     Русский
    
    ·
    
     日本語
    
    ·
    
     Deutsch
    
    ·
    
     한국어
    
    ·
    
     Italiano
    
    ·
    
     Polski
    
    ·
    
     Nederlands
    
    ·
    
     Türkçe
    
    ·
    
     Українська
    
   

   

    
     
      
      HolyArrs: one self-hosted app for shows, movies, music and downloads
     
    
   

   

    
     
      
       
       HolyArrs.com
      
     
    
    
     
      
       
       r/HolyArrs
      
     
    
    
     
      
       
       Discord
      
     
    
    
     
      
       
       Roadmap
      
     
    
    
     
      
       
       What's new
      
     
    
   

   

    
     Build
    
    
     OpenSSF Scorecard
    
    
     OpenSSF Best Practices
    
    
     Version
    
    
     Licence: AGPL-3.0
    
   

   

    

     Six apps to watch a show. Now it's one.
    

    
    
   

   

    
     HolyArrs
    
    is one self-hosted app for your shows, movies and music.
    

    Browse like a streaming app, ask for what you want, and it handles the rest.
   

   

    
     About 15 MB to download · about 140 MB of RAM idle with 10,000 titles · amd64, arm64, armv7
    
    

    
     The six apps it replaces download 718.2 MB together.
    
   

   

    
     Quick start
    
    ·
    
     Why
    
    ·
    
     What it does
    
    ·
    
     Moving from other apps
    
    ·
    
     The manual
    
    ·
    
     Help
    
   

   

    
     
      
      HolyArrs Explore: hover a title and the trailer plays
     
    
   

   

    

     🚀 Running in two minutes
    

    
    
   

   

    Save this as
    
     docker-compose.yml
    
    in a new folder on a local disk:
   

   

    
name: HolyArrs
services:
  holyarrs:
    image: holyarrs/holyarrs:latest
    container_name: holyarrs
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - /your/local/path:/config
      - /path/to/movies:/movies #optional
      - /path/to/tv:/tv #optional
      - /path/to/music:/music #optional
      - /path/to/downloads:/downloads #optional
    ports:
      - 6262:6262
    restart: unless-stopped

   

   

    Open
    
     http://your-server:6262
    
    and make the owner account. A short setup walks you through folders, a downloader and a Source.
   

   

    No API keys to hunt down. No second container. Every setting is explained in
    
     the manual
    
    further down.
   

   

    

     💡 Why I built it
    

    
    
   

   

    A normal media server runs six apps: Sonarr, Radarr, Lidarr, Bazarr, Prowlarr and Seerr.
   

   

    That's six logins, six ports, six update cycles and six API keys to copy between them. When a show doesn't land, you check six places to find out why.
   

   

    I wanted one app. One login, one port, one place to look.
   

   

    So I built it.
   

   
    

     
      

       
        App
       
       
        Download (amd64)
       
       
        Idle RAM
       
       
        Logins
       
       
        Web ports
       
      

     
     
      

       
        Sonarr
       
       
        87.9 MB
       
       
       
       
        1
       
       
        1
       
      

      

       
        Radarr
       
       
        91.0 MB
       
       
       
       
        1
       
       
        1
       
      

      

       
        Lidarr
       
       
        121.3 MB
       
       
       
       
        1
       
       
        1
       
      

      

       
        Prowlarr
       
       
        80.8 MB
       
       
       
       
        1
       
       
        1
       
      

      

       
        Bazarr
       
       
        156.4 MB
       
       
       
       
        1
       
       
        1
       
      

      

       
        Overseerr
       
       
        180.8 MB
       
       
       
       
        1
       
       
        1
       
      

      

       
        
         Six together
        
       
       
        
         718.2 MB
        
       
       
       
       
        
         6
        
       
       
        
         6
        
       
      

      

       
        
         HolyArrs
        
       
       
        
         14.9 MB
        
       
       
        
         ~140 MiB
        
       
       
        
         1
        
       
       
        
         1 (6262)
        
       
      

     
    

   
   

    
     About 48 times smaller. Compressed registry download, linuxserver.io images, amd64, measured 2026-11-08. Idle RAM measured with 10,000 titles and 55,000 movies and episodes.
    
   

   

    

     🎬 Ask for a title, and it shows up in your library
    

    
    
   

   

    Someone asks for a title. HolyArrs searches your Sources, picks the best release with your Pick rules, sends it to your downloader and files it in your library. Your media server hears about it when it lands.
   

   

    
     
      
      Browse like a streaming app. Ask for anything. It finds it. Straight to your downloader. Subtitles kept. Into your library.
     
    
   

   
    

     
      

       
       
       
       
      

     
     
      

       
        🍿
        
         Explore
        
       
       
        Browse like a streaming app. Hover a title and the trailer plays.
       
      

      

       
        🙋
        
         Requests
        
       
       
        A whole show or one season. You approve, or let trusted people skip the queue.
       
      

      

       
        🎯
        
         Pick rules
        
       
       
        You decide which release wins: size, quality, language.
       
      

      

       
        💬
        
         Subtitles
        
       
       
        In the languages you pick, kept with the file. Finding them online comes after 1.0.
       
      

      

       
        📅
        
         Calendar
        
       
       
        What's airing next for everything you follow.
       
      

      

       
        🚚
        
         Move your setup
        
       
       
        From Sonarr, Radarr, Lidarr, Prowlarr, Bazarr, Seerr, Overseerr, qBittorrent and SABnzbd. Try it first, undo it later.
       
      

      

       
        🔌
        
         Old-app API
        
       
       
        Prowlarr can keep pushing Sources to HolyArrs once you turn it on.
       
      

      

       
        🗝️
        
         No API keys needed
        
       
       
        Titles, artwork and charts come from the HolyArrs metadata server.
       
      

      

       
        🔒
        
         Encrypted keys
        
       
       
        Stored passwords and keys are locked with a master key that lives in your config folder.
       
      

      

       
        🪶
        
         Tiny
        
       
       
        An image of about 15 MB with nothing but HolyArrs inside.
       
      

     
    

   
   

    
     
      See every page in motion
     
    
    
    
   

   

    

     🤝 It works with what you already run
    

    
    
   

   

    
     
      
      Downloaders: qBittorrent, Transmission, Deluge, SABnzbd, NZBGet. Media servers: Plex, Jellyfin, Emby.
     
    
   

   
    
    
  • 
     
      Downloaders:
     
     qBittorrent, Transmission, Deluge, SABnzbd, NZBGet
    
    • 
    
  • 
     
      Media servers:
     
     Plex, Jellyfin, Emby
    
    • 
    
  • 
     
      Sources:
     
     any Torznab or Newznab indexer, or Prowlarr or Jackett
    
    • 
    
  • 
     
      Moves your setup from:
     
     Sonarr, Radarr, Lidarr, Prowlarr, Bazarr, Seerr, Overseerr, qBittorrent, SABnzbd
    
    • 
   

   

    

     🚚 Bring your old setup with you
    

    
    
   

   

    Open
    
     Settings > Move from other apps
    
    , add each old app's address and API key (or a backup zip), pick what comes over, run
    
     Try it
    
    , then
    
     Move
    
    . You can undo a move later.
   

   
    

     
      

       
        From
       
       
        What comes over
       
      

     
     
      

       
        Sonarr, Radarr, Lidarr
       
       
        Library folders, titles, quality profiles as Pick rules, exclusions, naming, indexers and download clients
       
      

      

       
        Prowlarr
       
       
        Indexers as Sources
       
      

      

       
        Bazarr
       
       
        Default subtitle languages
       
      

      

       
        Seerr, Overseerr
       
       
        People and their waiting or approved requests
       
      

      

       
        qBittorrent, SABnzbd
       
       
        Downloaders
       
      

     
    

   
   

    HolyArrs only reads your old apps and changes nothing in them, so you can run both side by side until you trust it.
   

   

    Keys and passwords stay behind; you type them in again or import them from a file. Custom formats, tags and history don't come over. Media files never move. Step by step:
    
     Move from other apps
    
    .
   

   

    

     🧭 What it doesn't do yet
    

    
    
   

   
    
    
  • 
     
      Downloading by itself.
     
     HolyArrs connects to qBittorrent, SABnzbd and the others. It doesn't replace them.
    
    • 
    
  • 
     
      AI or MCP features.
     
     Not in 1.0.
    
    • 
    
  • 
     
      Phone and TV apps.
     
     Not built. The web app works on a phone.
    
    • 
    
  • 
     
      Music in Explore
     
     is still being built.
    
    • 
   

   

    What's next is on the
    
     roadmap
    
    . You vote, I build. Post ideas on
    
     r/HolyArrs
    
    .
   

   

    

     ❓ Questions people ask first
    

    
    
   

   

    
     Do I keep qBittorrent or SABnzbd?
    
    Yes, for now. HolyArrs connects to the downloader you already run. A built-in downloader is planned for a later release.
   

   

    
     Can Sonarr and Radarr keep running while I try it?
    
    Yes. HolyArrs reads them once and never changes them.
   

   

    
     Is it free?
    
    Yes. It's free and open source.
   

   

   

    

     📖 The manual
    

    
    
   

   

    Everything below is reference. The full guides live at
    
     docs.HolyArrs.com
    
    .
   

   

    

     Supported architectures
    

    
    
   

   

    Pulling
    
     holyarrs/holyarrs:latest
    
    gets the right image for your machine.
   

   
    

     
      

       
        Architecture
       
       
        Available
       
       
        Runs on
       
      

     
     
      

       
        amd64
       
       
        ✅
       
       
        Most PCs, servers and NAS boxes
       
      

      

       
        arm64
       
       
        ✅
       
       
        Apple silicon, newer Raspberry Pis, ARM servers
       
      

      

       
        armv7
       
       
        ✅
       
       
        Older 32-bit ARM boards
       
      

     
    

   
   

    On a NAS? See
    
     Unraid, Synology and other NAS boxes
    
    .
   

   

    

     Version tags
    

    
    
   

   

    Images live on Docker Hub as
    
     
      holyarrs/holyarrs
     
    
    .
   

   
    

     
      

       
        Tag
       
       
        Use it for
       
      

     
     
      

       
        
         latest
        
       
       
        The newest release.
       
      

      

       
        
         1.0.9
        
       
       
        One exact version. It never moves.
       
      

     
    

   
   

    

     Usage
    

    
    
   

   

    

     docker compose (recommended)
    

    
    
   

   

    
name: HolyArrs
services:
  holyarrs:
    image: holyarrs/holyarrs:latest
    container_name: holyarrs
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - /your/local/path:/config
      - /path/to/movies:/movies #optional
      - /path/to/tv:/tv #optional
      - /path/to/music:/music #optional
      - /path/to/downloads:/downloads #optional
    ports:
      - 6262:6262
    restart: unless-stopped

   

   

    

     docker cli
    

    
    
   

   

    
docker run -d \
  --name=holyarrs \
  -e PUID=1000 \
  -e PGID=1000 \
  -e TZ=America/New_York \
  -p 6262:6262 \
  -v /your/local/path:/config \
  -v /path/to/movies:/movies `#optional` \
  -v /path/to/tv:/tv `#optional` \
  -v /path/to/music:/music `#optional` \
  -v /path/to/downloads:/downloads `#optional` \
  --restart unless-stopped \
  holyarrs/holyarrs:latest

   

   

    Container settings go in compose. Everything else is set in the app.
   

   

    

     Parameters
    

    
    
   

   

    Each one is written
    
     <outside>:<inside>
    
    . Change the left side only.
   

   
    

     
      

       
        Parameter
       
       
        Function
       
      

     
     
      

       
        
         -p 6262:6262
        
       
       
        The web app.
       
      

      

       
        
         -e PUID=1000
        
       
       
        The user HolyArrs runs as. See
        
         User and group
        
        .
       
      

      

       
        
         -e PGID=1000
        
       
       
        The group HolyArrs runs as.
       
      

      

       
        
         -e TZ=America/New_York
        
       
       
        Your time zone, for the calendar, schedules and logs.
        
         Etc/UTC
        
        when left out.
       
      

      

       
        
         -e UMASK=022
        
       
       
        Optional. Permission bits new files leave out. Use
        
         002
        
        when a group must write too.
       
      

      

       
        
         -v /config
        
       
       
        Databases, settings, the master key, backups and logs. Local disk only, never a network share.
       
      

      

       
        
         -v /movies
        
       
       
        Optional. A movie Library folder.
       
      

      

       
        
         -v /tv
        
       
       
        Optional. A shows Library folder.
       
      

      

       
        
         -v /music
        
       
       
        Optional. A music Library folder.
       
      

      

       
        
         -v /downloads
        
       
       
        Optional. Your downloader's download folder.
       
      

      

       
        
         --read-only=true
        
       
       
        Optional. Only
        
         /config
        
        and
        
         /tmp
        
        need to be writable.
       
      

      

       
        
         --user=1000:1000
        
       
       
        Optional. Start as a fixed user.
        
         PUID
        
        and
        
         PGID
        
        are then ignored.
       
      

     
    

   
   

    More variables (reverse proxy, URL base, save path):
    
     Environment variables
    
    .
   

   

    

     Environment variables from files
    

    
    
   

   

    Put
    
     FILE__
    
    in front of any variable to read its value from a file, such as a Docker secret:
   

   

    
environment:
  - FILE__HOLYARRS_ALLOWED_HOSTS=/run/secrets/holyarrs_hosts

   

   

    

     User and group
    

    
    
   

   

    
     PUID
    
    and
    
     PGID
    
    must match the user that owns your media folders. Find them with:
   

   

    
id youruser
# uid=1000(youruser) gid=1000(youruser)

   

   

    HolyArrs never changes the owner of your media or download folders. Give that user write access to them, because HolyArrs makes folders and moves files.
   

   

    

     Application setup
    

    
    
   

   

    Open
    
     http://your-server:6262
    
    and make the owner account right away. There is no default password. Until you make it, whoever opens HolyArrs first becomes the owner.
   

   

    The setup that opens next asks for your folders, a downloader and a Source. Guide:
    
     First run
    
    .
   

   

    

     Media folders
    

    
    
   

   

    The four optional mounts are the easy way to start. The cost: each mount is its own filesystem inside the container, so every import is a full copy.
   

   

    Want instant moves that take no extra space? Mount one parent folder with downloads and Library folders inside it, and give your downloader the same mount at the same path. Guide:
    
     Folders
    
    .
   

   

    

     Docker Desktop on Windows and Mac
    

    
    
   

   

    Use a named volume for
    
     /config
    
    . Media folders can stay host folders. Guide:
    
     Install
    
    .
   

   

    

     Keep your master key safe
    

    
    
   

   

    
     holyarrs.key
    
    in your config folder is what opens your stored passwords and keys. Backups don't include it, so keep a copy somewhere else. As the owner, open
    
     Settings > Backups
    
    and choose
    
     Download key kit
    
    . See
    
     Backups
    
    .
   

   

    

     Updating
    

    
    
   

   

    
docker compose pull
docker compose up -d

   

   

    If the new version changes how data is stored, HolyArrs makes a backup first. To go back to it:
    
     docker exec holyarrs /holyarrs restore --pre-update
    
    , then
    
     docker restart holyarrs
    
    . Never remove
    
     /config
    
    during an update. See
    
     Updates
    
    .
   

   

    

     Security
    

    
    
   

   
    
    
  • 
     The owner account is made at first visit. There is no default password.
    
    • 
    
  • 
     Stored passwords and keys are encrypted with
     
      holyarrs.key
     
     .
    
    • 
    
  • 
     The image has no shell inside it.
    
    • 
    
  • 
     Don't forward port 6262 on your router. Use a VPN such as Tailscale, or a reverse proxy with HTTPS.
    
    • 
    
  • 
     Report security problems privately:
     
      SECURITY
     
     .
    
    • 
   

   

    

     Support info
    

    
    
   

   

    The image has no shell, so
    
     docker exec -it holyarrs /bin/bash
    
    won't work. HolyArrs' own commands do:
   

   
    
    
  • 
     
    
      Follow the log:
     
    
    
    • 
    
  • 
     
    
      Check your setup. Every line says
      
       OK
      
      ,
      
       WARN
      
      or
      
       FAIL
      
      , and each
      
       WARN
      
      or
      
       FAIL
      
      says how to fix it:
     
    
     
    
      
    docker exec holyarrs /holyarrs doctor
    
     
    
    
    • 
    
  • 
     
    
      Locked out of the owner account:
     
    
     
    
      
    docker exec -i holyarrs /holyarrs reset-owner
    
     
    
    
    • 
    
  • 
     
    
      Version number:
     
    
     
    
      
    docker inspect --format '{{ index .Config.Labels "org.opencontainers.image.version" }}' holyarrs
    
     
    
    
    • 
   

   

    

     Troubleshooting
    

    
    
   

   
    

     
      

       
        You see
       
       
        Do this
       
      

     
     
      

       
        Permission denied on media folders
       
       
        
         PUID
        
        and
        
         PGID
        
        don't match the owner of those folders. Run
        
         id youruser
        
        , put those numbers in compose and recreate the container.
       
      

      

       
        Errors with the config folder on a network share
       
       
        The database needs a local disk. Move
        
         /config
        
        to a local path. Media folders on a share are fine.
       
      

      

       
        Port 6262 is already in use
       
       
        Change the left side only, for example
        
         6263:6262
        
        , and open
        
         http://your-server:6263
        
        .
       
      

      

       
        HolyArrs can't reach qBittorrent or SABnzbd
       
       
        Inside a container,
        
         localhost
        
        means the container itself. Use the downloader's container name on the same Docker network, or the host's IP address.
       
      

      

       
        Imports are copied
       
       
        Mount one shared parent folder. See
        
         Media folders
        
        .
       
      

     
    

   
   

    More:
    
     Troubleshooting
    
    .
   

   

    

     Where to ask
    

    
    
   

   
    

     
      

       
        You have
       
       
        Go to
       
      

     
     
      

       
        A question
       
       
        
         Discord
        
       
      

      

       
        An idea or a vote
       
       
        
         r/HolyArrs
        
        and the
        
         roadmap
        
       
      

      

       
        A bug
       
       
        
         Issues
        
        (bugs and roadmap only)
       
      

      

       
        A security problem
       
       
        
         SECURITY
        
       
      

      

       
        Anything else
       
       
        
         support@HolyArrs.com
        
       
      

     
    

   
   

    

     Contributing
    

    
    
   

   

    Read
    
     CONTRIBUTING
    
    , then
    
     Architecture
    
    and
    
     Setup
    
    . Open an issue before a big change.
   

   

    On your first pull request a bot asks you to accept a short licence agreement (
    
     CLA.md
    
    ). One click, once.
   

   

    

     Licence
    

    
    
   

   

    HolyArrs is free and open source under the
    
     GNU AGPL-3.0
    
    .
   

   

    Want to build it into a closed product? Email
    
     support@HolyArrs.com
    
    for a commercial licence.
   

   

    

     Keep it going
    

    
    
   

   

    HolyArrs is free, but it isn't free to run. Every install talks to a metadata server I pay for every month. Sponsors cover that, and buy more hours for the things you vote for.
   

   

    
     
      
       
       Sponsor HolyArrs
      
     
    
    
     
      
       
       Vote on the roadmap
      
     
    
   

   

   

    Built by
    
     CoderLuii
    
    .
    

    
     If HolyArrs saves you from running six apps, a star helps other people find it.
    
   

  

 




        

      

    
    

        

          
Open Graph images with Astro and Typst

        

        

          Lobsters
        

	

	  eaj.no
	

        

          2026-11-10 06:42:48
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   Links to blog articles look better when they’re accompanied by an image.
If the HTML head has a
   
    meta
   
   tag like this, it will happen automatically:
  

  
<meta
  property="og:image"
  content="https://eaj.no/posts/graph-images-with-typst/og.png"
/>

  

   My previous, tedious workflow for these kinds of images was to go to
   
    unspash.com
   
   ,
search for something like
   
    structure
   
   or
   
    archive
   
   , and then select an image
I thought would fit the theme of the post. Being both boring and error-prone,
I abandonded that process and set up a pipeline that generates image cards at build-time instead.
They look like this:
  

  

   The generated OpenGraph image for this blog post
  

  

   Let me show you how I did it.
  

  

   Typst
  

  

   
    Typst
   
   is a tool that generates high-quality documents from a simple markup language.
A lovechild of
   
    LaTeX
   
   and
   
    Markdown
   
   ,
it works great for math whilst also keeping the day-to-day text formatting syntax bearable.
As a small taste, this snippet (adapted from
   
    the Typst README
   
   )
  

  
#set page(width: 10cm, height: auto, margin: 1cm)
#set heading(numbering: "I.")

#let fib_1 = 1
#let fib_2 = 1

= The Fibonacci sequence
The Fibonacci sequence is defined through the
recurrence relation $F_n = F_(n-1) + F_(n-2)$,
with $F_1 = #fib_1$ and $F_2 = #fib_2$.
It can also be expressed in _closed form:_

$
  F_n = round(1 / sqrt(5) phi.alt^n), quad
  phi.alt = (1 + sqrt(5)) / 2.
$

  

   produces this fine document:
  

  

   The output of typst compile --format png --ppi 144 typst-example.typ
  

  

   By default the
   
    typst
   
   CLI will create a PDF, but it can also make PNGs. The above image was created with the command
  

  
typst compile \
    --format png \
    --ppi 250 \
    typst-example.typ

  

   But if you’d rather create something with a bit more pizzazz, by all means. How about
  

  
#set page(width: 1200pt, height: 630pt, margin: 80pt, fill: rgb("#FF1493"))
#set text(font: "Comic Sans MS", fill: white, lang: "no")


#grid(
  rows: (1fr, auto),
  align(left + horizon, {
    text(size: 72pt, weight: 800, "Typst very nice")
  }),
  text(size: 24pt, "Would typst again"),
)

  

   which yields
  

  

   This is clearly much better
  

  

   Fantastic.
  

  

   If all of my posts were titled
   
    “Typst very nice”,
   
   we’d be done, but, alas.
Luckily, typst accepts inputs to a document with
   
    --input key=value
   
   ,
which is put in a
   
    sys.inputs
   
   dictionary for the template to read.
So the template becomes
  

  
#set page(width: 1200pt, height: 630pt, margin: 80pt, fill: rgb("#FF1493"))
#set text(font: "Comic Sans MS", fill: white, lang: "no")

#let title = sys.inputs.at("title", default: "You forgot the title :(")
// Reading the input here ☝️

#grid(
  rows: (1fr, auto),
  align(left + horizon, {
    text(
      size: if title.len() > 70 { 60pt } else { 72pt },
      weight: 800,
      title,
    )
  }),
  text(size: 24pt, "Would typst again"),
)

  

   which, when rendered with
  

  
typst compile \
    --format png \
    --ppi 144 \
    --input title="Look ma, from the CLI!" fancy-typst-with-input.typ

  

   becomes
  

  

   It’s … perfect.
  

  

   Perfection.
  

  

   Let’s move on to generating the images at build-time.
  

  

   Astro
  

  

   This site is built with
   
    Astro, a static site generator
   
   .
Articles are written in Markdown, which is then bundled into a
   
    Content Collection
   
   by Astro. The details are irrelevant, what matters is that this lets me
define metadata which I can query through a Javascript API.
  

  

   The source code for the page template is at
   
    src/pages/posts/[id].astro
   
   .
There are a few notable things about this file path:
  

  
    
   
  1. 
    That it is in the
    
     src/pages/
    
    directory tells Astro that this should be rendered as a page.
   
    2. 
   
  2. 
    The remainder of the path,
    
     /posts/[id]
    
    , tells Astro where to put the page.
   
    3. 
   
  3. 
    
     [id]
    
    being in brackets means
    
     id
    
    is a dynamic parameter which must be defined at build time.
   
    4. 
  

  

   In other words, Astro needs to know every ID when building the site—it can’t generate infinitely many
IDs. A function called
   
    getStaticPaths
   
   exported from the template defines the set:
  

  
import type { GetStaticPathsResult } from "astro";
import { getCollection } from "astro:content";

export async function getStaticPaths(): Promise<GetStaticPathsResult> {
  const posts = await getCollection("posts");
  return posts.map((post) => ({
    params: { id: post.id },
    props: { post },
  }));
}

  

   That is, fetch every article, and use its
   
    id
   
   as the
   
    id
   
   parameter.
This is the object returned for the current page:
  

  
{
  params: { id: "open-graph-images-with-typst" },
  props: { post: {
    /* Everything the template needs to render a post */
  }}
}

  

   By default Astro will generate an HTML file, but it can also return other
kinds of responses. Together with this blog post I also put
the following snippet at
   
    src/pages/api/build-info.json.ts
   
   :
  

  
import type { APIRoute } from "astro";

export const GET = (async () => {
  const data = await getLatestJjMetadata();
  return new Response(JSON.stringify(data), {
    headers: { "content-type": "application/json" },
  });
}) satisfies APIRoute;

async function getLatestJjMetadata(): Promise<{
  changeId: string;
  committedAt: Date;
}> {
  // Implementation cut for brevity
}

  

   Note that there are no parameters in brackets, so this will create a
single JSON file at build time:
  

  
❯ tree dist/api
dist/api
└── build-info.json

  

   And just like that, this blog
   
    now has a JSON api
   
   .
  

  

   Note that the file extension is included in the path, i.e.
   
    .json.ts
   
   . This is
because when the dev server is running it sets the appropriate
   
    content-type
   
   header
to let the browser know what to do with the response, but once the page is built
the result is a file with
   
    .ts
   
   stripped off. The browser
then interprets the remaining file extension to know what content to expect at the path.
  

  

   You probably see where this is going: Create an API route which takes a post ID
as a parameter and ends in
   
    .png.ts
   
   , gets the post title using the Astro Content Collection API,
generates an image, and returns it in a response with the appropriate
   
    content-type
   
   header.
  

  

   You got it. Here’s the open graph image endpoint in its entirety, defined at
   
    src/pages/posts/[id]/og.png.ts
   
   :
  

  
import type { APIRoute, GetStaticPaths, InferGetStaticPropsType } from "astro";
import { getCollection } from "astro:content";
import { execFile } from "node:child_process";
import { promisify } from "node:util";

import { OPEN_GRAPH_TEMPLATE_PATH } from "@/utils";

const execFileAsync = promisify(execFile);

export const getStaticPaths = (async () => {
  const posts = await getCollection("posts");
  return posts.map((post) => ({
    params: { id: post.id },
    props: { title: post.data.title },
  }));
}) satisfies GetStaticPaths;

type Props = InferGetStaticPropsType<typeof getStaticPaths>;

export const GET = (async ({ props }) => {
  const { stdout } = await execFileAsync(
    "typst",
    [
      "compile",
      OPEN_GRAPH_TEMPLATE_PATH,
      "-",
      "--format",
      "png",
      "--ppi",
      "144",
      "--input",
      `title=${props.title}`,
    ],
    { encoding: "buffer" },
  );
  return new Response(new Uint8Array(stdout), {
    headers: { "content-type": "image/png" },
  });
}) satisfies APIRoute<Props>;

  

   Now go to
   
    eaj.no/posts/open-graph-images-with-typst/og.png
   
   , et voilà:
  

  

   The generated OpenGraph image from the above code
  

  

   When a sharing platform loads the image for an article, it might very well be cached for a long time.
Even if you decide to completely redo your entire branding, LinkedIn might insist on displaying your
previous hideous design unless you handle it. A simple trick is to use a throwaway
search parameter that doesn’t do anything other than make the URL unique:
  

  
/some-image.png?v=whatever

  

   A straightforward (but silly) solution for creating this parameter is to generate a random string of characters every time
the site is built, ensuring your image is always fetched anew.
I landed on using a hash of the typst template and the title, so that the cache key only
changes whenever the actual content does:
  

  
import { createHash } from "node:crypto";
import { readFileSync } from "node:fs";

export function openGraphImageCacheBuster(title: string): string {
  const template = readFileSync(OPEN_GRAPH_TEMPLATE_PATH);
  return createHash("sha256")
    .update(template)
    .update(title)
    .digest("hex")
    .slice(0, 10);
}

 




        

      

    
    

        

          
Debugging Rust in 2026

        

        

          Lobsters
        

	

	  blog.jetbrains.com
	

        

          2026-11-10 06:10:32
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   
    Rust logo
   
   

    Focus on what matters
   

  

  

   

    

     Rust is a great language for many reasons: safety, performance and tooling. However, debugging is maybe one of the weakest points still. Interestingly enough, the
     
      Rust debugging survey 2026 results
     
     show that the majority (53.2%) of Rust users don’t use a debugger
     
      at all
     
     . Many Rust developers (81.3%) say that prints are simply easier/faster. The setup is also another problem: many users find it difficult to set up a debugger and it’s not a beginner-friendly feature. Especially when you include async (28.1%) and macros (23.0%), stepping features break most of the time.
    

    

     However, the situation is still better than it was in 2021, when the survey was first conducted. The number of users who use a debugger has increased from 36% to 46.8%!
    

    

     This made me think:
     
      how is the debugging experience in Rust today?
     
     

     So let’s dive into the techniques and tools that are available and how they are used in practice.
    

    

     The Scenario
    

    

     We will be using the
     
      Graham scan algorithm
     
     as an example. The algorithm computes the convex hull of a set of points in a plane: the smallest convex shape that encloses every point. Basically, you can think of it as stretching a rubber band around a collection of nails.
    

    

     

      🐀: Here, I built a TUI with
      
       Ratatui
      
      to visualize the algorithm and the bug:
     

    

    

     
    

    

     The
     
      source code is available on GitHub
     
     .
    

    

     You can see that it fails to enclose P2: the computed fence is red while the expected fence is green. Now, let’s go through the available debugging techniques to fix it!
    

    

     1. println!, dbg! or tracing
    

    

     There is already a unit test that fails, so we can use it as a debugging loop. Simply add println! or dbg! statements to the code and run the test until we find the bug.
    

    

     
    

    

     
      Here, we print the intermediate ordering, rerun the failing test and see that points with the same polar angle are ordered farthest-first. Reversing the distance comparison fixes the ordering and the next test run passes.
     
    

    

     This is the most common way of debugging in Rust and it works well for small programs. However, you see
     
      the problem
     
     : it is an iterative and tedious process. You need to recompile and run the program every time which takes time. It is also not ideal for big projects. It still works though!
    

    

     

      🐀: What else?
     

    

    

     2. rust-gdb or rust-lldb in the terminal
    

    

     We can inspect the same failing test without changing the source code via
     
      rust-lldb
     
     or
     
      rust-gdb
     
     :
    

    

     
    

    

     From there, we set breakpoints, run only the failing test and inspect the current frame:
    

    

     
    

    

     
    

    

     At the breakpoint, a is 36 units squared from the pivot while b is only 4. The comparator uses b.cmp(a), so points with the same polar angle are sorted in reverse distance order.
     

     
      That is the bug:
     
     the farther point is processed first and later removed from the hull.
    

    

     So let’s apply the fix:
    

    

     
    

    

     We can also use the TUI to visualize it:
    

    

     
    

    

     

      🐀: Yay, the rubber band is now wrapped around all the points.
     

    

    

     Unlike print debugging, this lets us inspect more state without editing and recompiling the program after every question.
     
      The trade-off is a manual workflow
     
     : setting useful breakpoints and knowing which debugger commands to run.
    

    

     

      🐀: Okay, but is there a more friendly way to debug this?
     

    

    

     3. RustRover’s debugger
    

    

     
      RustRover
     
     is JetBrains’ cross-platform IDE built specifically for Rust. It integrates Cargo projects, tests, code analysis and debugging in one place (and it is free for non-commercial use!).
    

    

     The recommended way to install it is through the
     
      JetBrains Toolbox App
     
     , which also handles updates and lets you switch between stable and early-access-preview versions.
    

    

     RustRover provides a
     
      graphical interface for GDB and LLDB
     
     , which means we can use the same workflow as before but with a more user-friendly interface. Click the gutter to set a breakpoint, then click the debug icon next to the failing test.
    

    

     
    

    

     The
     
      RustRover debugger documentation
     
     covers custom configurations, stepping, watches and expression evaluation in more detail!
    

    

     

      🐀: Interesting… I thought this type of debuggers are only available for more mature languages like Python or Java. How does it work under the hood?
     

    

    

     Good question! There is actually some interesting Rust-specific machinery behind the debugger. In my
     
      Rust in Production episode with Matthias Endler
     
     , I explained how RustRover turns the source into its own PSI, then a typed high-level representation and finally MIR. When we evaluate a Rust expression or call a function during a debug session, RustRover lowers it to MIR and sends it to the debugger to execute against the paused process.
    

    

     

      🐀: So the debugger actually understands the Rust expression we are asking it to evaluate! Amazing.
     

    

    

     Bonus: AI-assisted debugging
    

    

     Recently we started to see the “
     
      AI-assisted
     
     ” prefix in many things… programming, writing, ordering food, etc. and I thought why not try it for debugging as well?
    

    

     

      🐀: So basically ask the agent to fix the bug for us?
     

    

    

     Not exactly. The agent is not a replacement for the debugger, but it can help us understand the problem and suggest fixes. Instead, we will ask the agent to debug the problem and watch it in action with RustRover’s debugger!
    

    

     

      Starting with
      
       RustRover 2026.3
      
      , the IDE’s integrated
      
       MCP server
      
      (Model Context Protocol) can expose the debugger to agents such as Codex and Claude Code. This means that instead of clicking around manually, the agent can start a debug session, set breakpoints, step through the program, read variables and evaluate expressions for us. See
      
       what’s new in RustRover 2026.3
      
      for the full release highlights!
     

    

    

     Simply open
     
      Settings → Tools → MCP Server
     
     , enable the server and click
     
      Auto-Configure
     
     next to your agent. Restart the agent afterwards and you’re set!
    

    

     
    

    

     Also, see the
     
      agentic debugging documentation
     
     for more details.
    

    

     Once the MCP is connected, we can give the agent a goal like this:
     

     
      “Debug and fix this problem with RustRover MCP
     
     “
    

    

     The result is:
    

    

     
    

    

     

      🐀: Oh cool, you’re running Codex inside RustRover with the new
      
       Air plugin
      
      , and we can watch it run the failing test, set breakpoints, inspect runtime values and fix the bug!
     

    

    

     Conclusion
    

    

     Rust debugging isn’t one workflow. You can use println!, rust-lldb, RustRover or even an AI-assisted debugger. Each has its own trade-offs and is suitable for different scenarios.
    

    

     

      🐀: Just pick the tool that works for you!
     

    

    

     If you’d like to watch this in action, check out the
     
      video version of this post
     
     , recorded at
     
      Rust Berlin Meetup
     
     :
    

    

     

      
     

    

    

     Cheers! 🧀
    

    

     

      Subscribe to Rust Blog updates
     

    

   

   
   
  

  

   

    

     Discover more
    

   

  

 




        

      

    
    

        

          
ChatGPT’s Teen Mode could deprive teenagers of a fundamental need | Robin Kirman

        

        

          Guardian
        

	

	  www.theguardian.com
	

        

          2026-11-10 06:00:50
        

        

          
          

            What young students stand to lose is more than cognitive skill: it’s a reliable sense of their own minds In August, OpenAI launched Teen Mode – a version of ChatGPT in which every user under 18 will automatically be enrolled – a year after a lawsuit alleged that ChatGPT had contributed to the suicid...
          

        

        

          
Original Article

          

 

  

   
    I
   
   n August, OpenAI launched Teen Mode – a version of ChatGPT in which every user under 18 will automatically be enrolled – a year after
   
    a lawsuit alleged
   
   that ChatGPT had contributed to the suicide of a 16-year-old named Adam Raine.
  

  

   For years, the tech industry has contested any causal link between its products and the harms named in a wave of similar lawsuits, each alleging that the companies had not merely failed to protect children but had deliberately designed products to exploit them.
  

  

   Teen Mode is a tacit admission of culpability and it reveals what the industry now acknowledges – and doesn’t – about its products’ negative effects on young users’ mental health.
  

  

   As a psychoanalyst who works with young people, I’ve been observing, up close, the impact of social media and AI on their psychological development: how these tools influence not only behavior or mood at the day-to-day level, but identity formation and character.
  

  

   Teen mode may address some of the harms done to teenagers. A deeper one remains.
  

  

   At the surface level, Teen Mode seeks to prevent some of the more obvious harms to young users: it provides guardrails against destructive content, parent notifications for self-harm concerns, and a prohibition on presenting itself as a friend, claiming personal feelings, or suggesting it is anything other than a tool. That last restriction is a direct response to the Character.AI wrongful death case, in which a fourteen-year-old
   
    formed an intense attachment
   
   to a chatbot.
  

  

   
   
  

  

   There’s a growing awareness that it’s not only the content AI delivers but the way AI behaves that can cause harm, and that recognition seems to have driven the design of another feature: Study Mode, Teen Mode’s built-in learning tool.
  

  

   Recent research has confirmed what we already knew: that versions of AI that simply do the work for kids produce short-term grade improvements that collapse the moment the tool is removed, leaving students worse off than if they’d never used it. Study Mode is meant to yield gains that will hold.
  

  

   Leah Belsky, OpenAI’s vice-president for education, calls it a transformation from “a straightforward answer engine into a cognitive tutor”. Socratic in approach, the feature refuses to supply answers, requiring the student to do much of the thinking herself.
  

  

   Teen Mode offers something genuinely new: accessible to any student with a phone, it gently pushes back on easy answers and creates rather than forecloses the discomfort of not-yet-knowing. For a teenager without access to a tutor or a teacher with time for her questions, a Socratic companion can offer a real democratization of intellectually rigorous support – and one that surpasses, in scope of knowledge and availability, what any human source could provide.
  

  

   Where tutors eventually go home, and parents get frustrated, or simply have other things to do, Teen Mode is a tireless interlocutor – arguably, the only invention in human history capable of sustaining infinite patience with a teen.
  

  

   Which is to say: it is, structurally, the too-good parent. And that is precisely where the problem begins.
  

  

   Donald W Winnicott, the British pediatrician and psychoanalyst who spent decades studying how a child’s sense of self emerges, argued that what a child needs from her environment is not perfection but sufficiency.
  

  

   The “good-enough” parent, his most famous concept, is good precisely because she is not always good: she is present enough to give the child a secure base, but limited enough – distracted, tired, occasionally wrong – that the child must repeatedly draw on her own resources and find herself capable. A too-good parent, if such a thing could exist, would spare the child that struggle entirely, and the sense of self it builds.
  

  

   Winnicott was writing about early childhood, but the argument extends into adolescence, when separating from other minds becomes the central task.
  

  

   Peter Blos, the psychoanalyst who mapped that terrain most carefully, described adolescence as the work of disengaging from the authority of the minds a teenager has depended on and discovering what, beneath all that, is actually hers. The teenager who is convinced her parents are idiots, her teachers are frauds, and every received opinion is suspect is doing the important work of clearing ground.
  

  

   What makes adolescence generative isn’t that teenagers get it right – it’s that they
   
    think
   
   they’re right – and that magnificent, insupportable conviction is what gives them the nerve to find out what they actually believe. The adolescent whose intellectual life is always accompanied, always guided, always met with a calibrated response, never gets to become her own authority.
  

  

   One could argue – and OpenAI’s designers probably would – that Teen Mode is a scaffold, not a crutch: that a teenager who learns to think in dialogue with a rigorous interlocutor will internalize that process and eventually need the tool less. But this assumes the incentive to let go ever arrives – unlikely, as the world moves rapidly toward more dependence on AI.
  

  

   And even if this were to happen, development is not clearly reversible in that way: what grows with a scaffold is not the same as what grows without one. Many tech executives seem to grasp this themselves, sending their own children to
   
    schools with the resources
   
   to enforce a mandate on unassisted work.
  

  

   For a teenager without those advantages, the default is Teen Mode. Or, worse, the version of AI without the Socratic guardrails.
  

  

   What those students stand to lose is more than cognitive skill: it’s a reliable sense of their own minds.
  

  

   We have already begun to recognize what constant connectivity does to the developing self in other domains. Jonathan Haidt’s synthesis of the data on smartphone use showed that the sharp rise in anxiety, depression, and suicidal ideation among teenagers coincides with the incursion of technology into unstructured, unsupervised time – displacing the private space in which an identity takes shape.
  

  

   Sherry Turkle, who has spent decades studying teenagers and technology, found that many report not knowing what they think until they’ve posted it and seen how others respond.
  

  

   
   
  

  

   What I encounter in my office goes further: young people who lack a reliable internal compass, who struggle to know what they feel or want. That instability is not incidental to the youth mental health crisis; it is the condition underlying it. A person without an internal compass is an anxious one: dependent on confirmation, uncertain of her own perceptions, and easily destabilized.
  

  

   This is the deeper harm the industry – and the designers of Teen Mode – have not addressed. Teen Mode may ask you to think, but it is still holding your hand, still guiding, still keeping the dependency going, and in doing so, exacerbates the developmental harm at the root of the crisis.
  

  

   Ultimately, a stable sense of self requires moments of genuine trial, of being tested and surviving. The blank page, faced alone, is one such crucible: a place where we encounter ourselves, in doubt and even dread, and also in discovery and joy.
  

  

   Writing in the 1850s, the German philosopher Arthur Schopenhauer observed: “To think for oneself is always a little uncomfortable, and that is why so few people do it.”
  

  

   Now we may be creating a generation for whom this challenge is rarely required. That loss, hard to measure and therefore likely to be ignored, is profound: it is only in passing through the discomfort Schopenhauer names – the strain of thinking by and for yourself – that a person comes to truly know she has a mind of her own.
  

  
 




        

      

    
    

        

          
What Constant Surveillance Is Doing to Children

        

        

          Hacker News
        

	

	  www.theatlantic.com
	

        

          2026-11-10 05:47:18
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   Our site’s security protections triggered a block. If you
                    think this was in error, email us at
   
    
     [email protected]
    
   
   . Please include how you got to this webpage and the
                    Cloudflare Ray ID located at the bottom of the page.
  

  

   If you would like to inquire about permission to access our
                    content, email us at
   
    
     [email protected]
    
   
   .
  

  

   Cloudflare Ray ID:
   
    a584ea07e82ab49c
   
  

  

   
    Back to
    
     The Atlantic
    
   
  

 




        

      

    
    

        

          
Meet the Sad Wives of AI

        

        

          Hacker News
        

	

	  www.wired.com
	

        

          2026-11-10 05:40:51
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   

    

     

      

       

        Are you married to a man who’s obsessed with AI? I’m so, so sorry.
       

      

      

       

        

         

          
           

            
             
             
             Illustration of a sad woman standing while a man tussles with multiple robots in the background on one side and a child...
            
           

          
         

         

          
           ILLUSTRATIONS: CAT SIMS
          
         

        

       

      

     

    

   

   

    

     

     

     

      

       
        If i had
       
       to listen to another minute of my husband talking about Claude Code, I might have actually died. It was 11 pm in Berkeley, California, where I was home alone with our 10-month-old daughter, and 2 am in Cambridge, Massachusetts, where he was visiting for his newish job in AI. “JUST LOOK AT THIS!” he shouted. The FaceTime camera zoomed toward a laptop sitting on a hotel bed. “SEE?!”
      

      

       See
       
        what
       
       , I thought. I wanted to shower. I still had to take the dog out.
      

      

       “ARE YOU LOOKING?” he shouted again. I wasn’t. I was looking at our real baby. But that’s the thing. There are two babies in this household now: the small human one and the large language model. Both demand constant attention. Both keep us up at 2 am.
      

      

       Is this a Sophie’s choice kind of situation? Please. I’d kill the AI baby in an instant.
      

      

      

       

        

         
          
           Image may contain Computer Electronics Mobile Phone Phone HandHeld Computer and Texting
          
         
        

       

      

      

       
        There’s a strange
       
       and under-discussed side effect of the
       
        AI boom
       
       : what it’s doing to family dynamics. By which I mean: how it’s potentially
       
        destroying
       
       family dynamics. I’m sure this applies to all kinds of families,
       
        gay
       
       or straight, rich or poor, with any AI-pilled members. The technology is coming, has come, for us all. But for the purposes of this story, I mostly spoke to white-collar heteros in the Bay Area, because that’s where a certain psychological crisis seems most acute. Often it goes like this: He works in AI, and she does everything and anything else. Other times, it’s bleaker: He desperately
       
        wants
       
       to work in AI—or feels he
       
        must
       
       work in AI—and she wants him to do literally anything else.
      

      

       Either way, the men go in and the women want out. How many? It depends on how you define “working in AI.” About 71 percent of “AI-skilled workers,” according to one report, are men, and there are roughly 35,000 open AI roles in the US at any given moment. Broaden that to include investors and you’re adding thousands more. Broaden it further to include every man who has mentioned to his wife that he is “looking at some opportunities in the space”—and we’re in the millions. Conservatively, that means hundreds of thousands of spouses, partners, and girlfriends, holding down the fort while someone mansplains the singularity to them. There are, in other words, a lot of us, and more of us are surfacing—gasping for air and a single conversation that doesn’t involve LLMs—by the day.
      

      

       There’s a name for our ranks. I call us the sad wives of AI.
      

     

    

    

     

      

       
        
         Image may contain Book Publication Comics Adult Person Face Head Electronics and Hardware
        
       
      

     

    

    

     

      
       First of all,
      
      I’m sorry. AI is already the only thing most people talk about here, and it’s even worse for the sad wives.
     

     

      One of them moved from New York for her husband’s career. He cofounded an AI company; now he’s head of design at another. “He’s so passionate about it,” she says. “I go along to get along.” That is, when she can remember what it is he does, exactly. “My eyes glaze over a bit. I tend to check out. I forget.” She does say his company is at the forefront of … something. Mostly, she’s tired. “I did not expect how homogenous it would be,” she says. “In New York, I had a friend who’s a teacher, a friend who’s a nurse, a friend in fashion, a friend in finance—and none of us talked about our jobs when we went out. Every time I go out in San Francisco, it feels like I’m at a work happy hour. I don’t get it.”
     

     

      In a way, it can’t be helped. Most days it feels like every billboard in the city is about AI. Every. Single. One. “I’m on the edge,” another AI wife tells me, “while my husband drives by and is like, ‘Oh wow, that’s my company’s billboard.’ Cool. Great.” She, like almost every sad AI wife I talk to, doesn’t want me to include the specifics of her situation. Marriages, social standings, and finances—anything to protect the equity!—are on the line.
     

     

      Some of the sad wives are obscenely rich; others are struggling. But the more I talk to them, the more I hear the same lines, the same complaints, the same clichés. The hours. The obsession. The sense that missing this moment would mean, for their AI-pilled spouses, missing the most important technological shift of a lifetime. “They really want to ride the wave,” one AI wife says. Another: “He’s always depressed about something.”
     

    

    

     

     

      

       

        
         
          Image may contain Face Head Person Photography Portrait Adult Art Book Comics Publication and Drawing
         
        
       

      

     

     

      
       Yana van der
      
      Meulen Rodgers, the chair of labor studies and employment relations at Rutgers University, has a blunt take: What’s happening in Bay Area households isn’t just a lifestyle story. It’s a labor market story. The AI boom, Rodgers says, is creating a “perfect storm” of forces reshaping household dynamics, playing out along predictably gendered lines.
     

     

      The story is older than Silicon Valley, of course. Every major technological boom has produced the same figure, the person who gives everything to the wave. During the industrial revolution, it was the factory worker. During the Gold Rush, it was the men who left their families and headed west. During the dotcom boom, it was the founders sleeping under their desks in SoMa. Now, it is the person who is building, building, always
      
       building
      
      —
      
       vibe coding
      
      at midnight, constantly upgrading their models—convinced that stopping for five minutes means missing everything. Economists call this the “ideal worker.” Rodgers calls it a trap. “Someone who works many hours, giving all of themselves to this new force,” she says. “That means less time at home for the partner, less time for care work.”
     

     

      Though things keep changing, some analyses suggest that women are about
      
       20 percent less likely than men
      
      to use generative AI. “It’s a function not of gender per se,” Rodgers suggests, “but of the occupations that women hold.” Women are disproportionately represented in jobs—education, health care, social services—that right now use AI less. The result could be a compounding disadvantage. Over time, it means less access to the boom’s financial rewards, more responsibility for the domestic labor it generates.
     

     

      And what happens when it doesn’t work out for the men? Many, if not most, won’t make it in AI, a lucrative but volatile business. “With job loss comes some depression,” Rodgers says. “Within the household, if one person is going through adverse mental health effects around job loss or uncertainty, the other naturally becomes the support person.” The cruel irony, for some sad wives, is that the moment their husband does leave AI, whether by choice or by force, there’s no relief. Now he’s home. Spiraling. Now she’s managing that too.
     

    

    

     

     

      
       It was nearing
      
      the end of my therapy session. I had been rambling for 50 minutes about the mental load, the changing hormones, whether my postpartum depression could really just be traced to the fact that it took longer than anticipated to fit back into my jeans. Then my therapist interrupted and asked what exactly my partner did for work again. “Oh,” I said. “Well, he’s head of AI at his company.”
     

     

      What she said next, I had to write down. Her client base, she allowed, is almost entirely women—women whose husbands, more often than not, are in some way professionally adjacent to AI. And it’s affecting their relationships. The pressure to keep up means zero boundaries at home. The very
      
       masculine
      
      energy of it all. And the constant fighting, which is about something
      
       bigger
      
      than them. He’s off in another world, a world of prompts and benchmarks and epiphanies, while she’s firmly in this one.
     

     

      The resentment builds quietly. Several of these sad wives, my therapist added, have turned down job opportunities in AI themselves. Not because they weren’t qualified, but because it’s hard to raise kids and disrupt civilization at the same time.
     

     

      Princess Diana famously said there were three people in her marriage. For the sad wives of AI, the third is a chatbot. I spoke to a few other family therapists, and they agreed with mine: The phenomenon is getting worse. “It’s a lot of tech wives,” one said, sighing. “A lot of tech wives.”
     

     

     

      
       A tiktok meme
      
      has been making the rounds recently:
      
       young women at their laptops
      
      or doing their makeup, captioned something like, “Working so hard so my man can work on his AI startup that loses $30K a month.” The comments section stands in solidarity: “I’m ded.” “Yas queen.” “Just so he can have ‘founder’ in his bio.” I tried to reach out to some of these women. None bit.
     

    

    

     

      I should also say I didn’t bother speaking to any of the actual husbands for this story. I’m sick of hearing from the men of AI. So many of us are. They have podcasts and Senate hearings and
      
       magazine profiles
      
      and probably a group chat with the president. They’ve been talked to—and I can’t stress this enough—
      
       enough.
      
     

    

    

     

      

       
        
         Image may contain Book Comics Publication Person Adult Face and Head
        
       
      

     

    

    

     

      
       On an unseasonably
      
      warm evening, I met up with two friends at a wine bar. Both are partnered with men somewhere on the AI spectrum—tangibly building it, wildly chasing it, or simply unable to shut up about it. We ordered something orange and natural, the kind of wine that signals you have opinions.
     

    

    

     

      We were in Oakland, which has always prided itself on being the anti–San Francisco—more diversity, less venture-funded cold brew. It has never been home to a single major tech company. It didn’t matter. Within four minutes, we were talking about AI.
     

     

      
       It’s so existential. I think about it and then I get depressed.
      
     

     

      
       Yeah. Don’t think about it!
      
     

     

      We thought about it for the next two hours.
     

     

      
       Every night, it’s just existential dread.
      
     

     

      And then, the men. Neither of my friends’ husbands actually
      
       makes
      
      money from AI. Not yet.
     

     

      There is this sense, I offered, among people in AI—and people adjacent to it, and people who are pretty sure it’s coming for them—that this is their last chance. They’ve tried everything else, these men, from writing screenplays to investing in crypto. It’s AI or bust. Their partners, meanwhile, have quietly taken on a second job: emotional support. Chief Existential Officer, uncompensated. No one asked us if we wanted the gig.
     

     

      So what happens now?
     

     

      
       Maybe we’ll just go back to the Stone Age.
      
     

     

      One friend has started lobbying for her family to become Outdoor People. The kind who go into the wilderness and disconnect. For a whole week, no access. Just don’t tell Claude.
     

     

      A pause.
     

     

      
       Do we want dessert?
      
     

     

     

      
       Here’s how Bridget
      
      Balajadia, a clinician at Lupine Counseling in San Jose, characterizes the AI husband’s situation: “If you don’t respond to an email at midnight, you could wake up and not have a job.” It’s relentless. “In this industry, you’re reachable all the time. You’re thinking about it in the shower, when you’re having sex, it never leaves.” And when it never leaves, the relationship buckles. “It turns into this around-the-clock thing where neither partner is getting what they need. They’re both building walls of resentment.”
     

    

    

     

      Which—we know already. But then Balajadia tells me two surprising things. The first is that some sad wives of AI don’t
      
       want
      
      to talk to her about their husbands. Why? “I’ve already worked through this with my chat,” they say. By which they mean … ChatGPT. Yes. Not only is AI driving a wedge between couples. It’s also become a primary tool for attempting to salvage their marriage.
     

     

      Balajadia isn’t impressed. “They’re not having great outcomes,” she says. “It’s not going to challenge you. You end up being validated. Then both of you don’t move the needle in conflict.”
     

     

      It gets worse. ChatGPT subsequently, in some situations, helps these sad wives explore the possibility of cheating. Some of them, Balajadia says, get “validating messages,” such as: “
      
       Yes, it makes sense that you’re seeking attraction elsewhere because your partner’s not giving it to you. He’s emotionally unavailable.
      
      ” She pauses. “That’s probably not a great idea. You probably should address the stuff that’s coming up in your marriage, not go have sex with someone else.”
     

     

     

      
       Some wives, it
      
      must be said, have uncomplicated relationships with AI. One tells me it has “supercharged” her life—wedding planning, caring for aging parents, housekeeping, veterinary advice. While her husband is focused on how AI will change the economy, she’s interested in how it will change
      
       her
      
      . Optimize her, really. “There’s just not enough hours in the day if I don’t try to gain efficiencies in some things.” In fact, she’s just vibe coded something or other. Maybe one day
      
       he’ll
      
      be a sad AI
      
       husband
      
      .
     

     

      Or
      
       robots
      
      will fix everything. Another wife tells me that her husband, who founded an AI startup, is convinced they will have a household robot within the decade. “Maybe after we have kids, I’ll be like, ‘Bring a robot in,’” she says. “Right now, I can’t wrap my mind around it, though maybe people felt that way about washing machines.” This in response to the question I ask everyone: Has any part of the AI boom made things
      
       better
      
      at home? Could it ever?
     

    

    

     

      The responses are generally uninspiring. Most of the time, the closest thing to a silver lining any sad wife can offer is that AI has given them something new to talk about at dinner.
     

     

     

      
       Each time it’s
      
      the same pattern: a generation (of men) convinced this is their moment, and everyone else trying to figure out where they fit. A bubble. And bubbles, as anyone who was here in 2001 can tell you,
      
       tend to burst
      
      . One AI wife—the one who drives past billboards for companies her husband has backed—puts it simply: “Half of our income is dependent on AI doing well.”
     

     

      Mine too. More than half, to be frank.
     

     

      Flying home from that same trip to Massachusetts, my husband found himself watching the screen of the passenger next to him. It was playing
      
       Train Dreams
      
      , a movie about a man who leaves his family for logging and railroad work in the American West, a century ago. Even without sound, he got a little emotional. “Is that what I’m doing right now?” he asked me later.
     

     

      The man in the film ultimately loses his wife and young daughter. He’s filled with regret for much of his life.
     

     

      “But I’m doing it
      
       for
      
      our daughter,” my husband assured me. And: “I’ve always wanted the things I’ve worked on to be necessary.”
     

     

      I thought about that for a while. Then I asked him to take the dog out.
     

     

     

      
       
        What Say You?
       
      
      

      
       Let us know what you think about this article in the comments below. Alternatively, you can submit a letter to the editor at
      
      
       
        
         [email protected]
        
       
       .
      
     

    

   

  

  

   

    
    
     
  • 
     
    • 
     
  • 
     
    • 
     
  • 
     
    • 
     
  • 
     
    • 
     
  • 
     
    • 
     
  • 
      
    
       How
       
        AI Agents
       
       Plunged the Tech World Into Chaos
      
    
     
    • 
     
  • 
      
    
       
        In your inbox:
       
       Will Knight’s
       
        AI Lab
       
       explores advances in AI
      
    
     
    • 
    

   

   

    

     
      
       
        
        
        
       
      
     
    

    

     

      
       Alessandra Ram
      
      is an Emmy- and Murrow-winning journalist and the cohost of
      
       
        Sabotage
       
      
      , a podcast from Good Luck Media. A Bay Area native, she lives in Berkeley with her husband, daughter, and a very fluffy dog. ...
      
       Read More
      
     

    

   

  

 




        

      

    
    

        

          
'C:\> FORMAT C:' – relax, it's just a screen saver

        

        

          Hacker News
        

	

	  fakedos.com
	

        

          2026-11-10 05:32:36
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  
  

   

    

     FakeDOS 2.0 · Screen saver for macOS
    

    

     The most realistic
     
      DOS
     
     since
     
      DOS
     
     .
    

    

     Leave your Mac alone for a few minutes and it becomes a 1990s PC: an AWARD BIOS counts through 32 MB of RAM, a VGA prompt starts blinking, and then a ghost begins to type. It boots. It crashes. It dials. It lies convincingly.
    

    

     v2.0 · macOS 13+ · Universal Binary · free
    

   

   

   

  

  
  

   

    C:\>
    
     TYPE README.TXT
    
   

   

    What is this?
   

   

    Welcome, traveller. You have just discovered
    
     FakeDOS
    
    , a macOS screen saver that simulates a pixel-perfect DOS machine. And more.
   

   

    Leave your Mac alone for a few minutes and something beautiful is going to happen: the screen fills with the warm 80×25 glow of a VGA text mode, an AWARD BIOS POST clicks through memory, and a friendly blinking
    
     C:\>
    
    prompt appears.
   

   

    Perfect for
   

   
    
    
  • 
     A conference room that does not need Slack popping up
    
    • 
    
  • 
     Pretending to be a 12-year-old running Landmark Test
    
    • 
    
  • 
     Tricking a co-worker into thinking you have lost it
    
    • 
    
  • 
     Actually getting people to leave you alone
    
    • 
   

  

  
  

   

    Features
   

   

    

     

      Five boot modes
     

    

    

     

      The Ghost Writer
     

     

      Leave the prompt idle and a ghost starts typing commands by itself. It alternates between operating systems in an endless loop of simulated productivity.
     

     
    
      
  • 
       Many DOS commands, boot linux, some Linux commands, boot dos, repeat
      
    • 
      
  • 
       Realistic typing speed with human-like typos
      
    • 
      
  • 
       Press any key to take over and the ghost vanishes
      
    • 
     

     

      

       
      

      

       
        Warp 5
       
      

      

       
        Speeds up everything, not just the ghost. 1 is slow, 9 skips all delays.
       
      

     

    

    

     

      Landmark speed test
     

     

      Type
      
       FDOS
      
      or
      
       LANDMARK
      
      at the prompt to see how fast your imaginary Pentium thinks it is.
     

     

      

       
        IBM PC/XT
       
       
        
        
       
       
        4.77 MHz
       
      

      

       
        IBM AT
       
       
        
        
       
       
        8 MHz
       
      

      

       
        486DX
       
       
        
        
       
       
        33 MHz
       
      

      

       
        Your Pentium
       
       
        
        
       
       
        166 MHz
       
      

     

     

      Pure nostalgia, zero benchmarking.
     

    

    

     

      Pentagon mode
     

     

      Type
      
       PENTAGON
      
      at the prompt. We cannot tell you what happens.
     

     

      ACCESS DENIED. CLASSIFIED.
     

    

   

  

  
  

   

    This is not a real DOS.
   

   
    
    
  • 
     
      OK
     
     Your files are safe.
    
    • 
    
  • 
     
      OK
     
     Your disk is safe.
    
    • 
    
  • 
     
      OK
     
     Your Mac is safe.
    
    • 
    
  • 
     
      OK
     
     Your network is safe.
    
    • 
   

   

    Absolutely nothing useful happens here.
   

   

    FakeDOS is a pure simulation. Every single command you type produces carefully crafted fake output. No files are read, written, moved or deleted. No network connections are made. No processes are started. No disks are formatted.
   

   

    When you type
    
     FORMAT C:
    
    , FakeDOS shows a terrifyingly realistic format sequence, complete with percentage counter and head/cylinder display, but your actual drive is perfectly untouched. When you type
    
     DEL *.*
    
    , nothing gets deleted. Ever.
   

   

    It simulates. It pretends. It lies convincingly.
    

    
     But it never, ever touches your real system.
    
   

   

    Not a terminal. Not an emulator. Not connected to the Pentagon. Probably.
   

  

  
  

   

    C:\>
    
     HELP
    
   

   

    Commands
   

   

    

     

      DIR
     

     

      List files in current directory
     

    

    

     

      CD
     

     

      Change directory
     

    

    

     

      TYPE
     

     

      Display file contents
     

    

    

     

      COPY
     

     

      Copy files
     

    

    

     

      MOVE
     

     

      Move files
     

    

    

     

      DEL
     

     

      Delete files (fake!)
     

    

    

     

      REN
     

     

      Rename files
     

    

    

     

      MKDIR
     

     

      Create directory
     

    

    

     

      TREE
     

     

      Show directory tree
     

    

    

     

      CLS
     

     

      Clear screen
     

    

    

     

      CHKDSK
     

     

      Check disk
     

    

    

     

      FORMAT
     

     

      Fake format (scary!)
     

    

    

     

      MEM
     

     

      Show memory map
     

    

    

     

      VER
     

     

      MS-DOS version
     

    

    

     

      DATE / TIME
     

     

      Current date and time
     

    

    

     

      BOOT
     

     

      Switch to DOS / Linux / C64
     

    

    

     

      LM
     

     

      Landmark speed test
     

    

    

     

      PENTAGON
     

     

      CLASSIFIED
     

    

    

     

      ???
     

     

      CLASSIFIED
     

    

    

     

      EXIT
     

     

      Quit FakeDOS
     

    

   

   

    Arrow keys scroll through the command history.
   

  

  
  

   

    

     Download FakeDOS
    

    

     
      FakeDOS.dmg
     
     
      v2.0 · macOS 13+ · Universal Binary · 4.2 MB
     
    

    

     Downloads since launch
     
      0000000
     
    

    

     Psst... the boss thinks
     
      C:\
     
     is empty. Type
     
      DIR
     
     anyway. Some files in the root directory were never meant for office hours.
    

   

   

    

     Installation
    

    
    
     
  1. 
      
       Drag
       
        FakeDOS.app
       
       into
       
        /Applications
       
       .
      
     
    2. 
     
  2. 
      
       Double-click to launch. It installs itself as a menu-bar icon.
      
     
    3. 
     
  3. 
      
       Click the menu-bar icon to configure or start manually.
      
     
    4. 
     
  4. 
      
       After the configured idle time (default: 5 min), FakeDOS takes over fullscreen.
      
     
    5. 
     
  5. 
      
       Type
       
        EXIT
       
       to return to your real desktop.
      
     
    6. 
    

    

     
      Cmd + ,
     
     opens six pages of pure control: idle time, warp speed, the ghost writer, sound and more. The PC speaker can be silenced. Your co-workers cannot.
    

   

  

  
  

   

    FakeDOS
   

   

    Version 2.0 for macOS
   

   

    FakeDOS started in 1991 as a Turbo Pascal prank on a FidoNet BBS and lived its first life as a screen saver for Microsoft Windows.
   

   

    Three decades later, it was ported to Swift/macOS so it can terrorize modern office workers who have never heard of AUTOEXEC.BAT.
   

   

    
     Klaus Rössler
    
    &
    
     Roger Kirchhoff
    
    

    Copyright (c) 1991 - 2026
   

  

  
  

   

    C:\>
    
     DIAL DISCORD
    
   

   

    Found a bug, have an idea for a new fake command, or just want to say hello? Join the FakeDOS community on our Discord server.
   

  

  

   » May the FAKE be with you. «
  

 




        

      

    
    

        

          
AI usage generates a fragile codebase

        

        

          Hacker News
        

	

	  evanxmerz.com
	

        

          2026-11-10 05:25:58
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   I can only speculate as to the reasons why I was laid off from Meta in May, but I suspect that one of the reasons is that I was a little bit more resistant to adopting AI/LLMs as coding tools than some of my peers. Don't get me wrong, I generated at least 90% of my code using AI in my last few months there, which was the minimum for a decent rating. But AI didn't 10X the amount of code I was writing. It didn't even 2X it.
  

  

   I was focused on code quality. I saw the code being pushed by some of my peers who were heavily reliant on AI, and I saw that it was brittle code. There were many subtle issues that would lead to tech debt in the long term, and even some glaring issues were ignored by very good programmers. For instance, I saw one of the best programmers on my team try to merge code that used javascript events for mouseover CSS effects rather than using the :hover selector, which is a totally unscalable way of writing mouseovers.
  

  

   Now I'm employed at another large tech company and I've fully made the switch to generating 100% of my code using AI because that's the expectation today. Still, I can see lots of people becoming aware that this isn't a sustainable way to continue development of a large scale SaaS product. AI tends to solve the problems that can fit within its context window very well, but it's totally oblivious to the long term issues that can't be understood in that relatively small frame.
  

  

   In this post I'm going to list four ways that AI usage results in a fragile codebase that isn't resilient to the demands of highly available and highly scalable SaaS applications.
  

  

   By the way, every word of this article was written by a human. Even though the following image was generated by AI, this article isn't AI slop.
  

  

   A worried robot places another piece of code into a codebase portrayed as a wobbly house of cards.
  

  

   Four ways AI makes codebases fragile
  

  

   Here are the four most common ways that I have seen AI generating a fragile codebase.
  

  

   1. AI writes shallow tests
  

  

   One of the most obvious failures of modern LLMs is that they tend to write simplistic automated test cases that don't cover the things that matter to humans. Frequently I see AI agents writing lots of tests of get/set methods which are trivial and don't typically require much testing. When AI writes e2e tests, they tend to only cover the cases which are already covered in the codebase. In other words, the AI writes tests only covering one type of user, or only covering surface level interactions. This creates massive gaps in the test coverage that are invisible to developers because they aren't captured by the line level coverage metric.
  

  

   2. AI writes overly complex ccode
  

  

   AI also tends to write overly complex code. It frequently uses two or three helper methods when a single one would suffice. It tries to follow coding guidelines, such as DRY, to a fault, without realizing that the added complexity of that rigidity makes the code more difficult for human developers to debug or understand.
  

  

   3. Reliance on AI decreases human understanding
  

  

   And that's the third issue with AI codebases: Humans don't understand them. The longer a company relies on AI agents to generate the code, the fewer developers are going to understand the codebase. This means that developers can't do the things that are necessary to build a resilient codebase. They don't understand the data structures and algorithms well enough to see when a pull request contains a new abstraction that doesn't work with the pre-existing structures.
  

  

   4. AI moves too quickly to maintain a high quality bar
  

  

   AI moves too quickly for human developers to maintain a high quality bar. Each pull request comes faster than the prior one and has to be reviewed in even less time. This leads to developers skimming the code and missing crucial details that result in long term tech debt. Small quality issues like testing gaps and poorly named variables accrue in the codebase until it becomes a morass of spaghetti code.
  

  

   Four signs that you have a fragile codebase
  

  

   If you're unsure whether coding agents are harming your codebase or not, then you might look for the following symptoms of a fragile, AI-generated codebase.
  

  

   1. AI generated codebases have more incidents
  

  

   When you switched the department over to agentic coding did the number of incidents slowly start rising? At first when we were all using agents to generate massive amounts of code, it didn't seem that different from traditional coding. The PRs came and were merged and everything seemed alright. But oh, there was that one p0 that came in at the end of the month, then there were two SEVs the following month. Then even more the next month. Now, after a year or two of agentic coding, it seems like there's an incident every weekend. AI coding agents are the reason why there are more incidents impacting customers.
  

  

   2. Recovery from incidents takes longer in AI codebases
  

  

   Not only are there more incidents, but the incidents take longer to be mitigated. The fact is that the human developers on your team now have a more shallow understanding of the codebase. If your coding agent can't find the issue that your customers are facing, then humans are going to have to dig through a codebase that is highly complex and poorly tested. They will essentially be entering unfamiliar territory, so it takes longer for them to figure out what is going wrong. Hence, companies lose more and more money to incidents that take longer to resolve.
  

  

   3. AI generated codebases create errors that are only visible to users
  

  

   When humans don't spend time in the code, they fail to see all of the use cases. They fail to understand how actual humans are using the code because they aren't ensuring that the AI is instrumenting analytics and catching all the errors properly. Hence, invisible errors start appearing in the codebase. Errors are uncaught and only visible to real world users, as opposed to the types of users that are being tested in automated tests or in developer manual testing.
  

  

   4. AI results in a poor user experience
  

  

   And that leads to the ultimate problem with AI codebases: they weren't made for humans. AI codebases are software made by AI for AI. They aren't being tailored to the way that human users use the product, and they aren't being tailored for the way human developers need to maintain the product. The experience degrades on both the user and the developer side, leading to a vicious cycle of enshittification.
  

  

   Products made for humans require a human touch
  

  

   The fact of the matter is that for a product to satisfy human customers, it has to be informed by a human perspective. Nobody likes ordering from machines at a restaurant. Shopping for clothes from a website always results in worse fits than shopping in person. The same is true of SaaS products. Any time you leave your SaaS product in the hands of a machine, you are losing the human touch that is valuable to your users and your developers. This may work for the cheapest products that only compete on price, but high quality software products will continue to have a human touch. The best, most expensive products will be tailored for human users by human developers. They will be charming and enjoyable to use. They won't be fragile because they won't be primarily developed by AI.
  

 




        

      

    
    

        

          
Hackers now exploit critical Barracuda ESG flaws to gain root access

        

        

          Bleeping Computer
        

	

	  www.bleepingcomputer.com
	

        

          2026-11-10 05:10:20
        

        

          
            

          
          

            Cybersecurity company Barracuda Networks warned that attackers have begun exploiting two recently patched Email Security Gateway (ESG) vulnerabilities that let them run commands with root privileges. [...]...
          

        

        

          
Original Article

          

 

  

   Barracuda
  

  

   Cybersecurity company Barracuda Networks warned that attackers have begun exploiting two recently patched Email Security Gateway (ESG) vulnerabilities that let them run commands with root privileges.
  

  

   Barracuda
   
    released security updates
   
   to address the two flaws (tracked as
   
    CVE-2026-116606
   
   and
   
    CVE-2026-111560
   
   ) one week ago.
  

  

   The first stems from an Email Security Gateway (ESG) authentication weakness that can be exploited to modify an appliance's global configuration, while the second lets unauthenticated attackers inject OS commands that execute with root privileges.
  

  

   
    image
   
  

  

   Barracuda also said that successful attacks require access to the administrative user interface (Admin UI) of targeted devices and advised customers to restrict access to trusted internal networks and use appropriate network access controls to limit exposure.
  

  

   "Successful exploitation requires an attacker to have access to the administrative interface of an affected product. If exploited in combination, these vulnerabilities could allow an attacker to bypass authorization controls and obtain root access to the device," the company explained.
  

  

   On Monday evening, Barracuda updated the initial advisory to warn admins that the two flaws are being exploited in attacks targeting a limited number of customers.
  

  

   "Barracuda immediately initiated a comprehensive remediation process and released security patches for affected products. We have identified exploitation activity affecting a small number of organizations,"
   
    it warned
   
   .
  

  

   "If a patch has not been automatically applied, customers should manually apply the appropriate patch as soon as possible. If customers have turned off automatic patching, Barracuda recommends setting devices to automatically receive patches."
  

  

   The table embedded below lists all affected devices and available security patches.
  

  

   
    

     
      Affected Product
     
     
      CVE-2026-116606
     
     
      CVE-2026-111560
     
     
      Patch
     
    

    

     
      Email Security Gateway (ESG)
     
     
      Yes
     
     
      Yes
     
     
      BNSF-40425 (9.4.017+),
      

      BNSF-40430 (<9.4.017)
     		
    

    

     
      Load Balancer ADC
     
     
      No
     
     
      Yes
     
     
      BNADC-16586
     
    

    

     
      Message Archiver (BMA)
     
     
      No
     
     
      Yes
     
     
      BNMA-32468
     
    

    

     
      WAF Control Center (WCC)
     
     
      No
     
     
      Yes
     
     
      BNWF-60060
     
    

    

     
      Web Application Firewall (WAF)
     
     
      No
     
     
      Yes
     
     
      BNADC-16586
     
    

    

     
      Web Security Gateway (WSG)
     
     
      No
     
     
      Yes
     
     
      BNYF-24789
     
    

   
  

  

   Three years ago, Barracuda patched another Email Security Gateway flaw (CVE-2023-7102) that the UNC4841 hacking group
   
    exploited in zero-day attacks
   
   to execute arbitrary code. The same year, UNC4841 abused another zero-day (
   
    CVE-2023-2868
   
   ) to target Barracuda ESG appliances as part of a series of cyber-espionage attacks.
  

  

   The company later revealed that the flaw had been exploited as a zero-day
   
    for at least seven months
   
   , since at least October 2022, to drop previously unknown SeaSpy and Saltwater malware and steal data from compromised devices.
  

  

   According to cybersecurity firm Mandiant, almost a third of systems breached in the 2023 campaign
   
    belonged to government agencies
   
   , most of them hacked between October and December 2022.
  

  

   Barracuda was founded in 2003 and now has more than 200,000 customers worldwide, including small- to medium-sized businesses (SMBs), large enterprises, and managed service providers (MSPs).
  

  

   

    
     article image
    
   

   

    

     
      Uncover email threats your existing defenses may miss.
     
    

    

     Adaptive Security's AI agents analyze email intent, context, and behavior to uncover phishing, business email compromise, and invoice fraud.
    

    

     See what's getting through with a 14-day read-only scan of Microsoft 365 or Google Workspace, with no MX changes.
    

    

     
      Start your free email security scan.
     
    

   

  

 




        

      

    
    

        

          
Turla hackers use new Cereal malware to spy on govt Exchange servers

        

        

          Bleeping Computer
        

	

	  www.bleepingcomputer.com
	

        

          2026-11-10 05:04:32
        

        

          
            

          
          

            The Russian state-backed threat group Turla has been using a new malicious toolset called 'Cereal' to intercept emails on Microsoft Exchange servers at government organizations. [...]...
          

        

        

          
Original Article

          

 

  

   Turla hackers use new Cereal malware to spy on govt Exchange servers
  

  

   The Russian state-backed threat group Turla has been using a new malicious toolset called 'Cereal' to intercept emails on Microsoft Exchange servers at government organizations.
  

  

   Researchers at cybersecurity company ESET documented the attacks in late 2025, initially finding modular .NET malware for Microsoft Exchange at a government body in Kazakhstan.
  

  

   A month later, ESET found the same toolset at a government agency in Romania, where it selectively gathered email correspondence with representatives of the North Atlantic Treaty Organization (NATO) and the European Union (EU).
  

  

   
    image
   
  

  

   "After fine-tuning our detections, we found the same toolset at a governmental organization in Romania - compromised on December 23rd, 2025," the researchers say in a report today.
  

  

   Turla, also known as Snake, Secret Blizzard, and Waterbug, is a cyber-espionage group active for more than two decades and linked to Russia's Federal Security Service (FSB).
  

  

   In the campaign analyzed by ESET, the hackers use the Cereal toolset, and specifically a component in the kit named CerealBox, to inject into Exchange’s
   
    EdgeTransport.exe
   
   process and hijack existing transport agents’ handlers.
  

  

   The malware executes commands in memory and can inspect email content without registering a new transport agent or interrupting normal email delivery in the Exchange server.
  

  

   Turla configured the malware to selectively collect messages containing document attachments such as .DOC, .DOCX, and .PDF files, and match certain sender, recipient, and subject criteria.
  

  

   Another malware component, called CerealNeuron, awaits for incoming encrypted web requests on paths resembling legitimate Exchange services, which carry commands for execution.
  

  

   CerealNeuron checks and decrypts the request, then executes the supplied CerealRunner program, a wrapper program that carries the code the attackers want to execute.
  

  

   

    Attack overview
    

     
      Attack overview
     
     

     
      Source: ESET
     
    

   

  

  

   Commands may include code to retrieve emails from Exchange, query Active Directory for users, groups, and DNS records, extract locally stored credentials, read files, or delete files.
  

  

   “The sheer volume of near-identical binaries, each compiled for a specific task, strongly suggests that the operators have an internal framework that automates the compilation and packaging of commands,”
   
    ESET says
   
   about the disposable programs serving as command carriers.
  

  

   “Combined with a codebase built around modular, interchangeable components, the impression is one of a mature, well-engineered platform – rather than a loose collection of scripts.”
  

  

   The CerealRunner components contain encrypted .NET programs and the arguments needed to run them, which execute in the host’s memory and then return their output to CerealNeuron.
  

  

   Eventually, CerealNeuron encrypts the output and sends it back to the attackers.
  

  

   

    Command execution flow
    

     
      Command execution flow
     
     

     
      Source: ESET
     
    

   

  

  

   ESET observed no external command-and-control (C2) infrastructure used in the attack, leaving the compromised Exchange server itself to serve as the only control point.
  

  

   The researchers also uncovered a variant of CerealNeuron called CerealHermit, which lacks network capabilities and instead reads commands from encrypted files on the disk.
  

  

   CerealHermit may serve as a fallback/redundancy system for when Neuron’s web channel becomes unavailable. However, ESET didn’t explain how attackers place Hermit’s command files on the server or retrieve the execution results.
  

  

   The researchers note that Cereal’s advanced concealment methods demonstrate Turla’s deep understanding of .NET execution techniques, including abusing the .NET native image cache to run inside legitimate processes.
  

  

   ESET says the Cereal toolset was designed for "long-term, stealthy cyberespionage," featuring a small disk footprint and relying on infrastructure that is less likely to be detected and blocked.
  

  

   The company has shared a complete list of indicators of compromise on its GitHub page.
  

  

   

    
     article image
    
   

   

    

     
      Uncover email threats your existing defenses may miss.
     
    

    

     Adaptive Security's AI agents analyze email intent, context, and behavior to uncover phishing, business email compromise, and invoice fraud.
    

    

     See what's getting through with a 14-day read-only scan of Microsoft 365 or Google Workspace, with no MX changes.
    

    

     
      Start your free email security scan.
     
    

   

  

 




        

      

    
    

        

          
Are walking pads worth it? We put the best under-desk treadmills to the test

        

        

          Guardian
        

	

	  www.theguardian.com
	

        

          2026-11-10 05:00:05
        

        

          
            

          
          

            Want to get your steps in while working or watching TV? Our expert puts walking pads through their paces to find the best for comfort, noise and ease of storage • The best treadmills for your home You don’t necessarily need to walk 10,000 steps a day to improve your health and wellbeing. In fact, th...
          

        

        

          
Original Article

          

 

  

   
    Y
   
   ou don’t necessarily need to walk 10,000 steps a day to improve your health and wellbeing. In fact,
   
    the NHS encourages
   
   a slightly more manageable target of just 10 minutes of brisk walking daily to introduce more moderate-intensity physical activity and reduce your
   
    risk of early death by up to 15%
   
   .
  

  

   However, even squeezing in “brisk walks” can be a chore, with busy schedules and increasingly desk-bound jobs forcing more of us to remain sedentary for long periods. That is where walking pads come in, being lighter, smaller and often easier to store than bulky and tricky-to-manoeuvre running treadmills.
  

  

   When coupled with a standing desk, walking pads can be used while working – or when watching TV in the evening. Just a couple of 30-minute sessions add thousands of steps to your daily tally. In fact, a 60-minute walk at an easy 3km an hour can burn between 200 and 300 additional calories.
  

  

   Walking pads are often cheaper than full-size treadmills, simple to use and relatively easy to store, and they’re perfect for adding more movement to your life without having to give up the day job.
  

  

  

   

    At a glance
   

   
  

  

  

   Why you should trust me
  

  

   I’m a keen fitness fan who does everything from gym-based strength training and kickboxing classes to outdoor trail runs and cold-water surfing. As a result, I’ve often been tasked with testing fitness technology for industry magazines, and I’m always keen to get stuck in.
  

  

   I strongly believe that you need to live with new tech for a bit to grasp how it fits into daily life, so I aim to test products for as long as possible and in the right environment. With walking pads, that meant strolling along, racking up the steps and burning calories – even while I wrote up this feature.
  

  

   How I tested
  

  

   

    
     
     
     
     
     
     
     
     
     
     
     
     
     A man walks on a compact walking pad treadmill facing a wall-mounted television in a living room
    
   

   

    
     
      
      
     
    
    
     Screen test: the walking pads were put through their paces in front of the TV as well as at a desk.
    
    Photograph: Leon Poultney/The Guardian
   

  

  

   There was only one way to properly trial the eight walking treadmills selected for this test, and that was to mimic the customer journey by ordering, taking delivery, unboxing, setting them up and then using them day to day.
  

  

   The best walking treadmills – or walking pads – aren’t quite as bulky as
   
    regular running treadmills
   
   , so I could have multiple models on the go at home at once: one under my desk, one in front of the television and one in my wife’s office upstairs, testing each for at least three days.
  

  

   The testing process involved a lot of additional steps and – in some cases at least – a whining soundtrack that drowned out whatever Netflix series the family was watching. Besides general observations on the heft, ease of storage and operation, quietness and build quality, I tested any additional features such as incline and speed adjustments, as well as any remote controls or apps.
  

  

   To get a good idea of energy consumption and the overall cost of running a walking treadmill, I plugged each unit into a power meter to calculate the cost based on the October energy price cap.
  

  

   Here are the four best walking pads you can buy now.
  

  

  

   The best walking pads in 2026
  

  

   

    
     
     
     
     
     
     
     
     
     
     
     
     
     A Urevo walking pad with a small digital display sits on a wooden floor
    
   

   

    
     
      
      
     
    
    
     Quiet, sturdy and packed with genuinely useful features: the Urevo SpaceWalk 5L.
    
    Photograph: Leon Poultney/The Guardian
   

  

  

  

   

    

     
      
       Best walking pad overall:
      
      

      Urevo SpaceWalk 5L smart walking pad
     
    

    

     

      

       
      

      

       

        Urevo
       

       

        SpaceWalk 5L smart walking pad
       

       

        from
        
         £237.49
        
       

      

      

       

        
         What we love
        
        

        Quiet, sturdy and packed with genuinely useful app features
       

       

        
         What we don’t love
        
        

        It’s a little bulky
       

      

     

     

      

       
        
        
        
        
        
        
        Closeup of the Urevo SpaceWalk 5L walking pad’s rear end with teal buttons
       
      

      

       
        
         
         
        
       
       Photograph: Leon Poultney/The Guardian
      

     

     

      
       
        £299.99 at Urevo
       
      
     

     

      
       
        £237.49 at Amazon
       
      
     

     

      The Urevo SpaceWalk 5L is one of the most fully featured walking pads I’ve tested. It combines excellent build quality with a quiet motor, automatic incline and a great free companion app – which makes it feel more like a proper piece of fitness equipment than a basic under-desk treadmill. It’s slim enough to slide under a sofa when not in use, yet robust enough to cope with daily walking or even light jogging.
     

     

      
       Why we love it
       

      
      Unlike most rivals, the SpaceWalk 5L’s accompanying app is genuinely useful. It allows you to record workouts and track steps, distance and walking time, while also offering structured walks with automatic incline adjustment.
     

     

      

       
        
        
        
        
        
        
        App screens for the Urevo SpaceWalk 5L walking pad, showing workout tracking and home dashboard
       
      

      

       
        
         
         
        
       
       
        Track record: log your walks and take part in fitness challenges.
       
       Photograph: Leon Poultney/The Guardian
      

     

     

      The software also syncs with Apple Health, while the proprietary app lets you take part in a number of on-demand workouts, where incline and speed are controlled automatically. It also offers virtual walks, where you can take a sort of video tour of exotic locations. Unfortunately, it doesn’t feature the FTMS protocol that allows it to beam speed, cadence and incline data to a third-party app like Zwift. So your virtual avatar won’t move on the screen without a workaround such as a third-party, cadence-sensing footpod or compatible smartwatch.
     

     

      It is one of the quietest walking pads I’ve tested, though. At my preferred 2.5km/h working/walking pace, the motor averaged just 48dB – barely louder than my keyboard as I was furiously typing up this review.
     

     

      Build quality is also noteworthy. The weighty, front-mounted motor gives it a reassuringly solid feel, while adjustable feet make levelling on uneven floors easy. Its claimed 12-point shock absorption system also provides enough cushioning for walking in just socks, although I’d still recommend trainers for longer sessions.
     

     

      The incline, which can be automatically controlled when using Urevo’s app, adds another dimension for anyone aiming to increase the intensity of their walks.
     

     

      Energy use is impressively low, too. At a comfortable 2.5km/h, the SpaceWalk 5L drew around 40W during testing, costing roughly 1p an hour based on the 1 October electricity price cap.
     

     

      At its 6km/h maximum speed, this rose to about 3p an hour, with the incline motor briefly drawing more power when adjusting the deck.
     

     

      While 6km/h is no more than a brisk walk or gentle jog, the SpaceWalk 5L feels stable throughout. It doesn’t fold, but its slim design and the integrated wheels make it easy to roll under a bed or sofa for storage.
     

     

      
       It’s a shame that …
      
      the incline functionality makes it slightly bulkier than the simplest ultra-slim walking pads.
     

     

      
       Size:
      
      124 x 51.5 x 15.5cm (LWH)
      

      
       Weight:
      
      23kg
      

      
       Walking deck size:
      
      40 x 100cm
      

      
       Maximum user weight:
      
      181kg
      

      
       Incline:
      
      0-9% automatic
      

      
       Maximum speed:
      
      6km/h
      

      
       Folding:
      
      no
     

    

   

   

    
    

     

      Urevo
     

     

      SpaceWalk 5L smart walking pad
     

     

      from
      
       £237.49
      
     

    

    

     

      
       What we love
      
      

      Quiet, sturdy and packed with genuinely useful app features
     

     

      
       What we don’t love
      
      

      It’s a little bulky
     

    

   

  

  

  

   

    

     
      
       Best budget walking pad and best for beginners:
      
      

      Bigzzia walking pad with incline
     
    

    

     

      

       
      

      

       

        Bigzzia
       

       

        Walking pad with incline
       

       

        
         £89.99
        
       

      

      

       

        
         What we love
        
        

        A very cheap pad with a surprisingly high top speed
       

       

        
         What we don’t love
        
        

        Short deck, noisy motor and basic controls
       

      

     

     

      

       
        
        
        
        
        
        
        A black walking pad treadmill with digital display on a wooden floor
       
      

      

       
        
         
         
        
       
       Photograph: Leon Poultney/The Guardian
      

     

     

      
       
        £89.99 at Amazon
       
      
     

     

      The Bigzzia is very much a budget walking pad, and it shows. The construction is basic, the running deck is narrow and short, and the display is hardly sophisticated. But it’s remarkably cheap and has a surprisingly high 10km/h top speed and a manual incline setting.
     

     

      
       Why we love it
       

      
      The Bigzzia’s biggest selling point is that 10km/h maximum speed. That’s considerably faster than most under-desk walking pads, and means it can double as a basic treadmill for walking and light jogging.
     

     

      However, the deck is so short that running at anything approaching its maximum speed feels unnerving. I’d be much happier using it for walking or, at most, very short bursts of jogging.
     

     

      The running surface has a surprisingly good grip, but there’s little flex or meaningful cushioning underneath, making longer sessions uncomfortable. It’s better suited to shorter walks than all-day use.
     

     

      It does come with an 8% incline, although this isn’t a motorised function. You simply flip out two feet at the sides and put the supplied rubber supports underneath them to raise the deck. No range of settings here.
     

     

      The simple display shows the basics: speed, calories, time and distance, automatically cycling between the figures as you walk. There isn’t really a way to lock it to any particular metric – another reminder that this is a very simple machine.
     

     

      Interaction is equally basic – via a small wireless remote control. Lose or break it, though, and you’ll be stuck. You also need to supply the AAA batteries for it.
     

     

      For portability, however, the Bigzzia shines. At just 12.86kg, it is light enough to pick up and carry, something I can’t say about many of the walking pads here. It also has a couple of small wheels at the front, so you can tip it and wheel it around if you prefer. And while the short deck might prove a drawback for running, it’s great for storage: it slides easily under a sofa or can be stored upright against a wall.
     

     

      Noise is another compromise, however. Walking at 2.5km/h, I measured about 52dB, with a noticeable whine and plenty of foot thump from the deck. It’s not disastrous for a walking pad at this price, but it’s certainly more obvious than the best machines I’ve tested.
     

     

      Power consumption is also higher than that of some rivals. I measured 54W at 2.5km/h (about 1p an hour at the UK electricity rates at the time of writing) and 166W at its 10km/h top speed (about 4p an hour). Running costs remain low overall, but it’s less energy efficient than some more sophisticated walking pads.
     

     

      Another omission worth knowing about is the lack of an automatic stop function. That means the motor will continue running if you fall or simply walk away, so you need to be a little more careful about how you use it.
     

     

      
       It’s a shame that …
      
      it’s let down by
      
      
      the short deck, noisy motor and basic controls, but it’s one of the cheapest walking pads out there.
     

     

      
       Size:
      
      104 x 49 x 11cm (LWH)
      

      
       Weight:
      
      12.86kg
      

      
       Walking deck size:
      
      37 x 90cm
      

      
       Maximum user weight:
      
      130kg
      

      
       Incline:
      
      0 or 8% manual
      

      
       Maximum speed:
      
      10km/h
      

      
       Folding:
      
      no
     

    

   

   

    
    

     

      Bigzzia
     

     

      Walking pad with incline
     

     

      
       £89.99
      
     

    

    

     

      
       What we love
      
      

      A very cheap pad with a surprisingly high top speed
     

     

      
       What we don’t love
      
      

      Short deck, noisy motor and basic controls
     

    

   

  

  

  

   

    

     
      
       Best lightweight walking pad
      
      :
      

      JTX MoveLight
     
    

    

     

      

       
      

      

       

        
         What we love
        
        

        Great build quality and crisp display
       

       

        
         What we don’t love
        
        

        It’s heavy and awkward to move around
       

      

     

     

      

       
        
        
        
        
        
        
        A foot steps on to a JTX treadmill displaying time and step count on its digital screen
       
      

      

       
        
         
         
        
       
       Photograph: Leon Poultney/The Guardian
      

     

     

      
       
        £449 at JTX Fitness
       
      
     

     

      JTX often appears in the “best value” section of home fitness equipment reviews, known for offering reliable build quality at affordable prices, but its machines tend to prioritise function over flashy design and cutting-edge technology.
     

     

      The MoveLight walking pad is different, however. It’s the most expensive walking pad in this roundup, and there’s a tangible difference in the build quality compared with cheaper walking pads. The JTX also offers a sizeable display, cushioned walking deck and quiet 1hp electric motor. It’s a solid treadmill offering speeds of up to 6km/h, meaning it’s possible to use it for slow jogging without the worry of it falling apart.
     

     

      
       Why we love it
       

      
      The MoveLight is similar in design to the BodyMax reviewed below and has a solid plastic chassis that gives it a more premium feel than its cheaper rivals. The running deck is generously sized and well cushioned, making longer walking sessions more comfortable.
     

     

      The extra-large LED console is easy to use and neatly scrolls through speed, time and step count as you walk. The shrill beeps upon startup and when you adjust the speed may cause office mates to want to throw a pencil at you, however.
     

     

      With the small plastic remote, you can adjust the speed, stop or start the unit and scroll the display between distance, calories and time on one half, and speed and step count on the other.
     

     

      The 1hp motor is powerful enough to propel the deck up to 6km/h, where it remains much quieter than some of the others tested.
     

     

      Overall, it feels like a walking pad that will go the distance – and so it should, given the price – but that solid build does make it a pain to move around the house; it will require some serious muscle to tip it up on to its wheels. It also doesn’t fold like the BodyMax machine.
     

     

      Oh, and one final public service announcement: those with wooden floors will want to take care that the wheels and plastic feet don’t scratch the surface during transport.
     

     

      During testing, I found it to be slightly more power-hungry than rivals, supping about 100W at 3.5km/h, meaning it costs about 3p an hour to power.
      
      
     

     

      
       It’s a shame that …
      
      it’s so big and heavy to move around, which makes storing it after each session a chore.
     

     

      
       Size:
      
      147 x 60 x 12.5cm (LWH)
      

      
       Weight:
      
      29.5kg
      

      
       Walking deck size:
      
      45 x 122cm
      

      
       Maximum user weight:
      
      100kg
      
       

      
      
       Incline:
      
      none
      

      
       Maximum speed:
      
      6km/h
      

      
       Folding:
      
      no
     

    

   

   

    
    

     

      JTX
     

     

      MoveLight
     

     

      
       £449
      
     

    

    

     

      
       What we love
      
      

      Great build quality and crisp display
     

     

      
       What we don’t love
      
      

      It’s heavy and awkward to move around
     

    

   

  

  

   
    
     Prefer to sit while you work? We’ve also reviewed
     
      the best office chairs
     
    
   
  

  

  

   

    

     
      
       Best foldable walking pad:
      
      

      BodyMax WP60
     
    

    

     

      

       
      

      

       

        
         What we love
        
        

        Genuinely foldable with an excellent walking experience
       

       

        
         What we don’t love
        
        

        It’s very heavy
       

      

     

     

      

       
        
        
        
        
        
        
        A BodyMax walking pad treadmill sits beneath a standing desk in a home office
       
      

      

       
        
         
         
        
       
       Photograph: Leon Poultney/The Guardian
      

     

     

      
       
        £399 at Fitshop
       
      
     

     

      One of the most expensive models on test, the BodyMax walking pad is also one of the best built and easiest on the eye. It’s the only model that genuinely folds in half, making it easier to squeeze into a cupboard or wardrobe.
     

     

      However, at around 30kg, it’s not the easiest to move, despite wheels at the front that allow it to be tipped on its end and rolled around.
     

     

      Potential portability issues aside, this machine offers a fantastic walking experience, with a neat, bright and easy-to-read LED panel that gives clear and scrolling readouts of workout time, distance, speed and average calorie burn.
     

     

      Very much the Porsche of the walking pad world, the BodyMax unit combines stylish looks and powerful performance.
     

     

      
       Why we love it
       

      
      Like most walking pads here, the BodyMax comes with a remote for adjusting speed, but its clever A Mode goes a step further, using foot placement to automatically adjust the pace.
     

     

      Stay in the middle, and it maintains pace; walk towards the front to speed up or hang back to slow down. It’s a useful touch that saves you constantly fiddling with the remote. The deck itself is nicely cushioned, and the motor is among the quietest on test.
     

     

      Those wanting their walking pad to double up as a running treadmill may be disappointed, however: the WP60 tops out at 6km/h, which is a very fast walking pace but a slow jog for most. Not a single walking pad I’ve tested has done a convincing job as a running treadmill, though, being either too flimsy underfoot, too noisy, or simply not built to withstand the endless thumping of a sprint session.
     

     

      If you’re seeking robust build quality, the BodyMax WP60 walking pad is well worth the additional outlay. As it folds in half, it can be tucked under a desk or rested against a wall when not in use.
     

     

      
       It’s a shame that …
      
      it’s heavy and awkward to move around when folded.
     

     

      
       Size:
      
      143 x 55 x 13cm (LWH)
      

      
       Weight:
      
      28kg
      

      
       Walking deck size:
      
      42 x 120cm
      

      
       Maximum user weight:
      
      100kg
      

      
       Incline:
      
      none
      

      
       Maximum speed:
      
      6km/h
      

      
       Folding:
      
      yes, folds in half for storage
     

    

   

   

    
    

     

      BodyMax
     

     

      WP60
     

     

      
       £399
      
     

    

    

     

      
       What we love
      
      

      Genuinely foldable with an excellent walking experience
     

     

      
       What we don’t love
      
      

      It’s very heavy
     

    

   

  

  

  

   What you need to know
  

  

   

    
     
     
     
     
     
     
     
     
     
     
     
     
     A hand holds a white remote control above a black walking treadmill, seen from above
    
   

   

    
     
      
      
     
    
    
     Using a walking pad for an hour each day should only add about £10 a year to your energy bills.
    
    Photograph: Leon Poultney/The Guardian
   

  

  

  

   What should I look for when buying a walking pad?
  

  

   The biggest difference between walking pads, aside from overall build quality, is their top speed. Most max out at about 6km/h, which is ideal for walking while working at a standing desk or a brisk stroll in front of the TV. If you’re hoping to jog as well, look for models that reach 8-10km/h – although be aware that you’ll generally sacrifice some stability and comfort compared with a full-size treadmill.
  

  

   Next comes incline. Premium models tend to offer a motorised incline function that can be adjusted at the touch of a button, while cheaper alternatives rely on manually extending support feet for a fixed gradient. Even a small incline can noticeably increase calorie burn and make walks feel more challenging.
  

  

   
    
     skip past newsletter promotion
    
    
   
  

  

   Also pay attention to the size of the walking deck. A longer, wider belt will feel far more comfortable and safer, particularly if you’re tall or have a long stride. Finally, think about practicalities such as noise, storage, transport wheels, companion apps and maximum user weight. If you plan to use your walking pad for several hours a day while working from home, spending a little more on a quieter, sturdier model is usually money well spent.
  

  

   
    How much should I spend?
   
  

  

   Prices vary when it comes to walking pads, with the most affordable costing about £90. Anything less than that is unlikely to be long-lasting. From my testing, the sweet spot seems to be about £250, where you can get a good blend of value and decent build quality. Some of the best I tested were, predictably, among the most expensive. These high-end models typically cost about £500.
  

  

   
    How much room do you need?
   
  

  

   If you’ve got good clearance underneath a bed or sofa, most walking pads will happily slide underneath without the need to fold them up. Imagine a slimmed-down treadmill without the safety handle, and you’re basically there.
  

  

   Models such as the BodyMax WP60 fold in half, which drastically reduces the length (or height, depending on how you store it), making them much easier to slide into more compact spaces such as a cupboard or wardrobe. But bear in mind they can weigh up to 30kg, so they can be tricky to move without help.
  

  

   
    How easy is it to maintain a walking pad?
   
  

  

   Most walking pads come with a small bottle of silicone oil. This is used to lubricate the underside of the walking belt
   
   
   every couple of months to ensure smooth movement, depending on use. Most manufacturers also supply the required hex key so you can adjust the belt if it’s slipping or has moved slightly off-centre.
  

  

   Quickly check the belt alignment and any moving parts every couple of months, and it should be enough to keep a walking pad running smoothly for years.
  

  

   
    Can I run on a walking pad?
   
  

  

   Some walking pad speeds are capped at about 6km/h, which makes running on them tricky. A plodding jog is a better description. A few of the walking pads I tested did reach much higher speeds, and most of these came with a folding safety handle that extends to allow them to safely reach those speeds, giving the runner something to hang on to should the worst happen. These also came with a separate safety system: a small magnetic tag that attaches to clothing. If this becomes detached, the machine shuts off.
  

  

   The general build and robustness of walking pads aren’t up there with their running-focused counterparts, though. That means they can be noisy, shift around underfoot and generally feel a bit flimsy during faster and longer runs. On top of this, those without handles don’t always have the automatic shut-off functionality, which can make them more dangerous, particularly when using them at higher speeds.
  

  

   In summary,
   
    running treadmills
   
   are better suited to those wanting to move at higher speeds. They feature more underfoot cushioning or built-in suspension systems, which make longer, faster sessions more comfortable and easier on the joints.
  

  

   Can you use a walking pad on carpet?
  

  

   In most cases, yes, but it depends on both the walking pad and the type of carpet. Most manufacturers recommend using a walking pad on a hard, level surface as this provides the best stability and allows air to circulate around the motor. Thick, plush carpets can restrict airflow, increasing the risk of overheating, while also making the machine less stable underfoot.
  

  

   If carpet is your only option, a low-pile carpet is usually fine, especially with a treadmill mat underneath. This helps spread the load more evenly, protects the carpet from compression and reduces vibration travelling through the floor.
  

  

   Regardless of the surface, ensure enough clearance around the machine for safe use and so that the belt runs freely without rubbing. It’s also worth checking underneath every so often to remove dust and fluff, especially if you have pets, as debris can build up around the motor and rollers over time.
  

  

   What does weight capacity mean, and what other safety features should I look for?
  

  

   Maximum user weight isn’t just about whether a walking pad can physically support you – it’s also an indication of how robust the frame, motor and deck are. Choosing a model with a higher weight capacity can often mean a more stable, longer-lasting machine.
  

  

   Beyond that, look for an emergency stop function or safety key if you intend to jog. Some walking pads automatically stop the belt if they detect you’ve stepped off, while others continue running until you turn them off manually. As I found during testing, not every budget model includes this feature, so check before you buy.
  

  

   A wide, grippy walking surface also improves confidence, particularly if you’re working at a standing desk, while decent shock absorption can reduce fatigue during longer sessions. Finally, ensure the walking pad has non-slip feet and is sitting securely before every use, as even slight movement can become distracting or unsafe – not to mention damaging to expensive wooden floors.
  

  

   What’s the difference between a walking pad and a treadmill?
  

  

   Although they look similar, walking pads and treadmills are designed for different purposes. Walking pads prioritise compact size, low noise and easy storage, with many slim enough to slide under a sofa or bed. They’re primarily designed for walking rather than running, making them ideal for staying active while you work or watch TV.
  

  

   Traditional treadmills are larger, heavier and more versatile. They typically offer higher top speeds, wider and longer running decks, better cushioning and features such as adjustable incline, heart rate monitoring and structured workout programmes. Their larger belts also make them far better suited to regular running.
  

  

   The trade-off is space. If your goal is simply to increase your daily step count or stay active while working from home, a walking pad is usually the more practical choice. But for race training or more serious fitness goals, a conventional treadmill remains the better investment.
  

  

   
    
     For more:
    
    

    
     
     
     
      The best exercise bikes – tested
     
     

     
     
     
      The best running watches to hit your fitness goals
     
     

     
     
     
      The best cross trainers
     
    
   
  

  

   
    Leon Poultney has been traversing the worlds of consumer technology and automotive for some of the biggest lifestyle websites and magazines for longer than he cares to divulge. A lifelong fitness enthusiast, he can often be found trying not to injure himself on a mountain bike/surfboard/other extreme thing, often at the request of an editor. Whether it is getting to know the latest connected kettlebells or partaking in CrossFit sessions, Leon is always willing to put his body on the line for great editorial
   
  

 




        

      

    
    

        

          
Queens Public library under ransomware attack e-borrowing suspended

        

        

          Hacker News
        

	

	  connect.queenslibrary.org
	

        

          2026-11-10 04:04:39
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   
    All QPL locations remain open as scheduled. However, certain virtual and in-person programs may be impacted. Please check with your local branch.
   
  

  

   
    You can continue to borrow and return books and other materials at all locations. During this outage, however, renewals are unavailable. As a reminder, customers are not charged late fines on borrowed materials.
   
  

  

   
    Check this page for updates. You can also check our social media channels:
   
  

  
  

   
    You may call (718) 990-0728 for assistance.
   
  

  

   
    We apologize for any inconvenience and ask for your patience and understanding as we manage this challenge. Our team is working diligently to restore full access. Please note it will take some time before the Library’s network and systems are restored.
   
  

 




        

      

    
    

        

          
Fossil CO2 emissions decrease by 0.4% in 2026

        

        

          Hacker News
        

	

	  news.exeter.ac.uk
	

        

          2026-11-10 03:59:41
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   Global carbon emissions from fossil fuels are projected to decrease by 0.4% in 2026 – driven by expansion of solar and wind power and the Iran conflict – according to new research by the Global Carbon Project.
  

  

   The 2026
   
    Global Carbon Budget
   
   projects 38.2 billion tonnes of fossil carbon dioxide (CO2) emissions this year.
  

  

   Emissions from oil are projected to decrease by 1.9% – likely a short-term response to the energy shock triggered by the Iran conflict.
  

  

   While global energy demand continues to rise, two thirds of the increase is being met by increased solar and wind power and electric vehicles.
  

  

   However,
   
    the report
   
   – published alongside a
   
    new paper in the journal
    
     Nature Climate Change
    
   
   – finds that clean energy growth is not yet fast enough for a durable decline in global fossil CO2 emissions.
  

  

   With emissions from land-use change (such as deforestation) projected to increase slightly this year, total CO2 emissions are projected to be 43.3 billion tonnes in 2026 – up from 42.8 billion tonnes last year.
  

  

   The remaining carbon budget (the amount of CO2 that can be emitted before warming reaches 1.5°C above pre-industrial levels) is now 150 billion tonnes – equivalent to less than four years of emissions at the current rate.
  

  

   With CO2 still rapidly accumulating in the atmosphere, the dangerous impacts of climate change continue to increase.
  

  

   The report also assesses natural “sinks” (absorption of CO2 by land and ocean). It finds that the land sink returned to former levels after a severe weakening during the 2023-24 El Niño weather pattern.
  

  

   However, the powerful 2026 El Niño is expected to have a significant impact in the coming year.
  

  

   The research team included the University of Exeter, the University of East Anglia (UEA), CICERO Center for International Climate Research, Ludwig-Maximilian-University Munich (LMU), Alfred-Wegener-Institut and more than 90 other institutions around the world.
  

  

   “A decline in fossil CO2 emissions is encouraging, but a reduction driven partly by geopolitical shocks is not a sustainable climate solution,” said Professor Pierre Friedlingstein, director of the Global Carbon Budget Office at the University of Exeter, who led the study.
  

  

   “The long-term answer remains the rapid deployment of clean energy technologies. While renewables and electric vehicles are increasingly offsetting growth in energy demand, further acceleration is needed if global emissions are to peak and enter a sustained decline.”
  

  

   Professor Corinne Le Quéré, Royal Society Research Professor at UEA’s School of Environmental Sciences – who led the new analysis published in
   
    Nature Climate Change
   
   – said: “Clean technologies are making a real difference in reducing global emissions. Solar and wind power and electric vehicles are expanding rapidly, led by China. Countries on every continent are decreasing their emissions while growing their economies. A further acceleration could turn the tide on global emissions within a few years.”
  

  

   Glen Peters, Research Professor at the CICERO Center for International Climate Research, said: “A drop in emissions in one year is not a peak unless it is driven by structural change. Accelerated deployment of solar, wind, batteries, and electric vehicles are pushing emissions down in dozens of countries, and slowing emissions growth in many more, but the changes are not sufficient to lock in a peak in global emissions”.
  

  

   Professor Julia Pongratz, at LMU’s Department of Geography, said: “Alongside reducing emissions, we need to scale up CO2 removal to reach greenhouse gas neutrality. Afforestation and reforestation already remove substantial amounts of CO2, but these gains are still more than offset by emissions from deforestation, and novel carbon removal remains very limited. We need to act on all these fronts now.”
  

  

   Other key findings from the 2026 Global Carbon Budget include:
  

  
    
   
  • 
    
     China’s
    
    emissions in 2026 are projected to decrease by 0.9%, following two
    
    
    years of low emissions growth. In addition to a strong decrease in oil emissions,
    
    
    coal emissions rose slightly (0.3%) and electricity generation from renewables
    
    
    continues to grow strongly.
   
    • 
   
  • 
    While China produces
    
     32% of global fossil emissions
    
    , it is also the country
    
    
    
     most active in deploying clean technologies and increasing carbon sinks
    
    
    
    through reforestation. Half of the global emissions avoided due to renewable
    
    
    energy and electric vehicles are in China, which also has the largest carbon
    
    
    uptake through reforestation and afforestation (new forests).
   
    • 
   
  • 
    The
    
     USA’s
    
    emissions are projected to decrease by 1.3%, mainly due to a
    
    
    decrease in coal emissions (which spiked last year due to high natural gas prices
    
    
    and cold weather).
   
    • 
   
  • 
    
     India’s
    
    emissions are projected to increase by 4.4% – higher than the 3.5%
    
    
    average annual growth over the last decade.
   
    • 
   
  • 
    
     European Union
    
    emissions are projected to decrease by 1.5%.
   
    • 
   
  • 
    
     Japan’s
    
    emissions are projected to decrease by 1%.
   
    • 
   
  • 
    Emissions for the
    
     rest of the world
    
    are projected to decrease by 0.7%. The
    
    
    largest component of the decline is in oil, likely driven by increased prices and
    
    
    global supply constraints.
   
    • 
   
  • 
    Projected 2026 emissions for the different fossil fuels are:
    
     oil
    
    down 1.9%,
    
    
    
     natural gas
    
    down 0.3%,
    
     coal
    
    up 0.6%.
   
    • 
   
  • 
    Emissions from
    
     international aviation
    
    and
    
     international shipping
    
    are both
    
    
    projected to decrease by 1%. Aviation’s decline is partly due to reduced activity
    
    
    in the Middle East.
   
    • 
   
  • 
    Global CO2 emissions from
    
     land-use change
    
    have decreased in the past decade
    
    
    but are projected to rise this year to 5.1 billion tonnes. This is driven by an
    
    
    increase in emissions from peat fires (almost entirely ignited by human
    
    
    activities) and forest degradation in Southeast Asia, associated with drier
    
    
    conditions linked to the onset of El Niño conditions.
   
    • 
   
  • 
    
     Total CO2 emissions
    
    – the sum of fossil and land-use change emissions – have
    
    
    grown more slowly in the past decade (0.3% per year), compared to the previous
    
    
    decade (1.7% per year).
   
    • 
   
  • 
    Emissions from permanent
    
     deforestation
    
    remain high at around 3.8 billion
    
    
    tonnes of CO2 per year over 2016-25. Permanent removals through
    
    
    
     reforestation and afforestation
    
    offset around half of the permanent
    
    
    deforestation emissions.
   
    • 
   
  • 
    The largest carbon uptake through re/afforestation occurs in
    
     China, the EU27
     
    
     and the USA
        
    , with combined removals 0.8 billion tonnes CO2 per year.
    
    
    Substantial uptake through re/afforestation also occurs in other regions such as
    
    
    
     Brazil, Russia and Indonesia
    
    – but here it is outweighed by emissions from
    
    
    deforestation.
   
    • 
   
  • 
    Current levels of novel
    
     Carbon Dioxide Removal
    
    (excluding conventional
    
    
    means such as reforestation) currently offset less than 30 minutes of annual
    
    
    fossil CO2 emissions.
   
    • 
   
  • 
    The
    
     concentration of CO2 in the atmosphere
    
    is set to reach 427.7 ppm in 2026,
    
    
    54% above pre-industrial levels.
   
    • 
  

  

   The analysis published in
   
    Nature Climate Change
   
   found:
  

  
    
   
  • 
    With global energy demand growing, new emissions can be prevented (or
    
    
    “offset”) by simultaneous growth in clean energy. The paper makes a projection
    
    
    from now to the end of 2028, finding that 64-79% of emissions from new demand
    
    
    will be offset by new solar and wind power and electric vehicles.
   
    • 
   
  • 
    The number of countries reducing their emissions while growing their economies
    
    
    is clearly increasing: 59 countries emitted less in 2025 than before the COVID-19
    
    
    pandemic in 2019, while their economies grew.
   
    • 
   
  • 
    Even in countries where total emissions increased over the 2019-25 period,
    
    
    growth in emissions has slowed in all regions including in China, India and other
    
    
    emerging economies.
   
    • 
   
  • 
    The effect of electric vehicles is growing rapidly but remains small because the
    
    
    vehicle stock takes time to be replaced, with only about 10% of the car fleet
    
    
    electrified in 2025 (or 6% excluding hybrids).
   
    • 
   
  • 
    Emissions avoided by solar and wind power rose from 0.28 billion tonnes in
    
    
    2010 to 4.1 billion tonnes in 2025, and a projected 4.6 billion tonnes in 2026.
   
    • 
   
  • 
    The authors conclude that: “If further acceleration of clean technology
    
    
    deployment can be supported through time, a sustained peak and decline in
    
    
    global CO2 emissions could be a few years away.”
   
    • 
  

  

   The Global Carbon Budget report, produced by an international team of more than 140
   

   scientists, provides an annual, peer-reviewed update, building on established
   

   methodologies in a fully transparent manner.
  

  

   The 2026 edition (the 21st annual report) is published in the journal
   
    Earth System
    

    Science Data
   
   
    on November 10 as a pre-print
   
   , and later as a peer-reviewed paper.
  

  

   The
   
    Nature Climate Change
   
   paper is entitled:
   
    “A further acceleration of clean energy is
    

    needed for global CO2 emissions to peak and decline.”
   
  

  
 




        

      

    
    

        

          
Google patches eighth Chrome zero-day exploited in attacks this year

        

        

          Bleeping Computer
        

	

	  www.bleepingcomputer.com
	

        

          2026-11-10 03:51:25
        

        

          
            

          
          

            Google has released emergency security updates to patch a new Chrome vulnerability exploited in zero-day attacks, the eighth such flaw since the start of the year. [...]...
          

        

        

          
Original Article

          

 

  

   Google Chrome
  

  

   Google has released emergency security updates to patch a new Chrome vulnerability exploited in zero-day attacks, the eighth such flaw since the start of the year.
  

  

   "Google is aware that an exploit for CVE-2026-125350 exists in the wild," the company said in a
   
    Monday security advisory
   
   .
  

  

   As Google explained, this flaw stems from a Use-After-Free (UAF) weakness in the XML component of the Google Chrome web browser, which occurs when the browser's XML parser processes data, deletes an object from the computer's memory, but fails to clear the pointer referencing that object.
  

  

   
    image
   
  

  

   Attackers can exploit this high-severity memory corruption vulnerability when the browser later tries to use or read that "freed" memory space to manipulate the memory layout and execute malicious code.
  

  

   While Google has found evidence of attackers exploiting this zero-day bug in the wild, it has not shared additional details about these incidents.
  

  

   "Access to bug details and links may be kept restricted until a majority of users are updated with a fix. We will also retain restrictions if the bug exists in a third party library that other projects similarly depend on, but haven't yet fixed," it noted.
  

  

   Google has now fixed the zero-day for users in the Stable Desktop channel, with new versions rolling out to Windows, macOS (157.0.8103.50/.51), and Linux users (157.0.8103.50). Although Google says the security update could take days or weeks to reach all Chrome users, it was available immediately when BleepingComputer checked for updates today.
  

  

   Google Chrome 157.0.8103.51
  

  

   If you don't want to update the web browser manually, you can also let Chrome check for updates on its own, as it will automatically install them after the next launch.
  

  

   ​Since the start of the year, Google has addressed seven other actively exploited zero-day vulnerabilities:
  

  
    
   
  • 
    An iterator invalidation bug (CVE-2026-2441) in CSSFontFeatureValuesMap (Chrome's implementation of CSS font feature values), which Google
    
     addressed in mid-February
    
    .
   
    • 
   
  • 
    
     Two other Chrome zero-day
    
    bugs exploited in attacks were patched in March: an
    
     out-of-bounds write
    
    weakness in the Skia 2D graphics library (CVE-2026-3909), and an inappropriate implementation vulnerability in the V8 JavaScript and WebAssembly engine (CVE-2026-3910).
   
    • 
   
  • 
    A use-after-free weakness in
    
     Dawn
    
    (CVE-2026-5281), the underlying cross-platform implementation of the WebGPU standard used by the Chromium project, which Google
    
     patched in April
    
    .
   
    • 
   
  • 
    An out-of-bounds read and write vulnerability in Chrome's V8 JavaScript engine (CVE-2026-11645), exploited in the wild and
    
     patched in June
    
    .
   
    • 
   
  • 
    And
    
     out-of-bounds write
    
    (CVE-2026-87491) and
    
     type confusion
    
    (CVE-2026-85046) flaws in the V8 JavaScript engine, fixed in September.
   
    • 
  

  

   Google fixed eight more
   
    zero-days exploited in attacks
   
   in 2025, many of them reported by the company's Threat Analysis Group (TAG), which tracks zero-day exploits used in spyware attacks.
  

  

   

    
     article image
    
   

   

    

     
      Uncover email threats your existing defenses may miss.
     
    

    

     Adaptive Security's AI agents analyze email intent, context, and behavior to uncover phishing, business email compromise, and invoice fraud.
    

    

     See what's getting through with a 14-day read-only scan of Microsoft 365 or Google Workspace, with no MX changes.
    

    

     
      Start your free email security scan.
     
    

   

  

 




        

      

    
    

        

          
Fireworks AI discloses new breach after cloud provider hack

        

        

          Bleeping Computer
        

	

	  www.bleepingcomputer.com
	

        

          2026-11-10 02:49:58
        

        

          
            

          
          

            AI infrastructure startup Fireworks has disclosed a new security breach in which attackers accessed its development machines after breaching a third-party cloud provider. [...]...
          

        

        

          
Original Article

          

 

  

   Fireworks AI
  

  

   AI infrastructure startup Fireworks has disclosed a new security breach in which attackers accessed its development machines after breaching a third-party cloud provider.
  

  

   FireWorks provides a high-performance inference platform for developers who want to deploy and run open-source artificial intelligence models (such as Mistral, Meta's Llama, or Google's Gemma) without worrying about hardware bottlenecks and complex infrastructure tasks.
  

  

   The company notified law enforcement and customers of another security incident in early October after attackers accessed environment variables containing API keys and tokens stored as secrets for a limited number of accounts.
  

  

   
    image
   
  

  

   "The evidence indicates links to a cybercriminal threat actor group, which is financially motivated and aimed at selling tokens from unauthorized access to Large Language Models (LLMs) to illicit routing gateways, known as 'LLMJacking',"
   
    Fireworks said
   
   at the time.
  

  

   After revoking compromised internal credentials, affected Fireworks API keys, and keys created by the attackers, Fireworks discovered another security incident on October 23.
  

  

   In the new breach, the threat actors accessed resource metadata (e.g., Fireworks resource identifiers, display names, descriptions, creation time), billing information (e.g., billing and shipping addresses, invoice and payment history, account balance, and credit usage), and incomplete model weights and datasets for some customers.
  

  

   However, the company said the attackers couldn't access customer payment card numbers because Fireworks doesn't store them.
  

  

   "A third-party cloud provider that hosted Fireworks R&D machines experienced a security incident on October 23. On October 24, the unauthorized third party used it to reach Fireworks development machines and then run an unauthorized workload that led to additional customer data impact,"
   
    Fireworks noted
   
   in a Monday advisory.
  

  

   "We detected this activity on the same day, and followed our incident response processes to take immediate remediation measures and close known critical vulnerabilities. As of October 25, we have not detected further evidence of successful unauthorized access by the threat actor on the Fireworks platform customers use."
  

  

   Since the attack, Fireworks revoked and replaced credentials and service accounts, restricted unauthorized network pathways, isolated affected systems, and tightened access to data storage and analytics systems to block public or unauthorized access to stored data.
  

  

   The company is now working with Palo Alto Networks' Unit 42 incident response division to secure its systems against future attacks and further investigate the incident's full scope and impact.
  

  

   One week ago, researchers at Google's Threat Intelligence Group (GTIG) and Mandiant reported that large language model hijacking attacks (also known as LLMjacking) are
   
    
     driving record costs for compromised organizations
    
    , with cloud AI charges reaching
   
   as high as $1 million due to fraudulent calls using stolen API keys.
  

  

   

    
     article image
    
   

   

    

     
      Uncover email threats your existing defenses may miss.
     
    

    

     Adaptive Security's AI agents analyze email intent, context, and behavior to uncover phishing, business email compromise, and invoice fraud.
    

    

     See what's getting through with a 14-day read-only scan of Microsoft 365 or Google Workspace, with no MX changes.
    

    

     
      Start your free email security scan.
     
    

   

  

 




        

      

    
    

        

          
M John Harrison becomes first science fiction author to win the Booker prize

        

        

          Hacker News
        

	

	  www.theguardian.com
	

        

          2026-11-10 02:40:52
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   Eighty-one-year-old M John Harrison has won the Booker prize for
   
    The End of Everything
   
   , a postapocalyptic novel set on a near-future Kent coast, becoming the oldest winner in the award’s history.
  

  

   Gaby Wood, chief executive of the Booker Prize Foundation, said that while plenty of previous winners had dabbled in science fiction, Harrison’s was “the first Booker winner to have emerged from the bona fide SF world”. She called it “a historic win, for a writer whose decades of work are lightly worn on every page”.
  

  

   Harrison, who has been publishing for six decades, overtakes Margaret Atwood, who was 79 when
   
    she shared the prize in 2019 for The Testaments
   
   . He received the £50,000 award and trophy at a ceremony in London on Monday evening.
  

  

   The End of Everything, Harrison’s first Booker nomination, is set a few decades from now, years after a disaster nobody can properly account for. Set on the Kent coast, the novel sees Phillip Tennent and his ageing aunt Marnie attempting to survive alongside the looming threat of the mysterious iGhetti: vast, shape-changing beings whose origins and intentions are never explained. At 198 pages, it was the shortest book on the shortlist.
  

  

   
   
  

  

   
    Mary Beard, chair of the judges
   
   , said the decision was unanimous, reached after a full day of discussion. “It’s a book that turns you upside down, raises a wry smile – and surprisingly, given the subject matter, leaves you with a twinge of optimism,” she said. “One main point of the book is that if, or when, such an apocalypse comes it will be incomprehensible. And the old rules won’t matter either … This is the politics of now seen through the lens of the future.”
  

  

   Harrison, born in Rugby, Warwickshire, in 1945, sold his first story in 1965 and spent most of the 1970s running the books pages of the speculative fiction magazine New Worlds. Alongside his novels he has written five short-story collections and
   
    the “anti-memoir” Wish I Was Here (2023)
   
   . Climbers took the Boardman Tasker prize for mountain literature in 1989, Nova Swing the Arthur C Clarke award in 2007, and The Sunken Land Begins to Rise Again the Goldsmiths prize in 2020. Once a keen climber and fell runner, he sat on the Booker judging panel in 2022.
  

  

   This year’s shortlist included two former winners: Marlon James, the bookmakers’ favourite, for
   
    The Disappearers,
   
   and Douglas Stuart for
   
    John of John.
   
   Elizabeth Strout’s
   
    The Things We Never Say
   
   , Luke Kennard’s
   
    Black Bag
   
   and Rebecca Perry’s debut
   
    May We Feed the King
   
   completed the list. Each shortlisted author receives £2,500.
  

  

   Writing in the Guardian on his inspiration last week,
   
    Harrison described
   
   The End of Everything as “a disaster story in which the disaster is the failure to comprehend”, with aliens who arrive “as incomers from another dimension, paralleling the gentrification of places like the UK’s south-east coast”. He admitted to passing on to the reader “some of the puzzlement and confusion of the characters”, but said he hoped the issues were transparent – among them “the collapse of rationality that comes with Trumpism and the internet”.
  

  

   His win marks a rare moment of mainstream recognition for a writer long revered by his peers but at the margins of literary fiction. On BBC Radio 4’s Front Row last month, Harrison said he had been “working for 40 to 50 years to shift the balance, both as a novelist and as a critic”, adding: “Why shouldn’t a well written [work of] SF be considered to be literary fiction?”
  

  

   Even admirers concede the book is not an easy read. In a
   
    rave review for the Guardian
   
   , Michel Faber said it “exposes the terrifying insecurity of life right now”, but warned that “it won’t be for everyone”.
  

  

   The win is timely in the age of AI. Beard noted that the “i” in iGhetti hints “at something digital, but you can’t be sure”, while Wood described the book’s post-apocalyptic landscape as “Large Language Model-dotted”.
  

  

   The judging panel also included Pulp frontman Jarvis Cocker, authors Patricia Lockwood and Raymond Antrobus and Guardian journalist Rebecca Liu. They considered 163 books published in the UK or Ireland between 1 October 2025 and 30 September 2026.
  

  

   It is the first Booker win for Serpent’s Tail, an imprint of the independent publisher Profile Books, and its fifth nomination. Hungarian-British author David Szalay
   
    won last year with Flesh
   
   ; other recent winners include Samantha Harvey’s Orbital, Paul Lynch’s Prophet Song and Shehan Karunatilaka’s The Seven Moons of Maali Almeida.
  

  
    
   
  • 
    
    
     The End of Everything by M. John Harrison (Profile, £16.99). To support the Guardian, order your copy at
     
      guardianbookshop.com
     
     . Delivery charges may apply.
    
    
   
    • 
  

 




        

      

    
    

        

          
Building a networking switch ASIC chip

        

        

          Lobsters
        

	

	  essenceia.github.io
	

        

          2026-11-10 02:39:39
        

        

          
            

          
          

            This is part 2, for part 1 see https://essenceia.github.io/projects/ethernet_switch_asic/
Comments...
          

        

        

          
Original Article

          

 

  

   
    
     
      
      
     
    
   
   
    AI disclosure: All bugs are 100% human made.
   
  

  

   Well that was a ride, where do I start ?
  

  

   I am currently on a quest to build some open source networking equipment with the final boss being a full router.
  

  

   There are a lot of very valuable and less complex pieces of hardware on the way that also need building, one of them being the common networking switch.
  

  

   Previously I was building the infrastructure to handle ethernet packets and worked my way up to a simple three-port switch that I had taped it out via Tiny Tapeout. But a few days after that tapeout, as I was still reeling from the adrenaline of rushing to meet the deadline, an unexpected opportunity presented itself: the possibility of taping out my own full chip, free of charge!
  

  

   
   

    Full chip inital global placement in action, performed by the OpenROAD placement tool.
   

  

  

   But there was one slight problem, I only had four days to design the entire thing, also known as 96 hours ( putting it in hours definitely does not make it sound less terrifying ).
  

  

   A few months back, I wrote that building a full matrix multiplication accelerator with some in-silicon debug infrastructure in under 2 weeks was too tight of a deadline, all around a terrible idea and should absolutely never be attempted, especially not in a corporate setting.
Well since then I have discovered a new circle of hell: designing a full ASIC solo in 4 days.
  

  

   It’s caffeinated down here.
  

  

   But now that I have gazed upon these new depths of hell, let me tell you about the journey of building full ASICs!
  

  

   Will the fab talk to me?
   
    
     #
    
   
  

  

   No … no they won’t …
  

  

   But they will talk to wafer.space, and wafer.space will talk to me.
  

  

   Now I suspect you might be wondering: what is wafer.space again ?
  

  

   A few months ago, something happened.
Tim Ansell, formerly part of the team at Google that got us the SkyWater 130nm and GlobalFoundries 180nm open source PDKs, left Google and started wafer.space where he opened up the possibility for mere mortals to taped out their own chip at GlobalFoundries for an affordable price.
They offer the services of getting your chip manufactured on GlobalFoundaries 180nm and optionally get it packaged.
  

  

   Big chips and little chips
   
    
     #
    
   
  

  

   Chips come in all rectangular sizes with the size measured in area.
  

  

   Area is one of the primary concerns of the design as it is once again a question of cold calculated economics, because, when you go to get a chip manufactured you pay per \( mm^2 \) of area.
  

  

   Take for example the price quoted bellow by IHP (another fab) for their own multiwafer runs. If you participate in this run you will get back a set number of chips (40 in this case) and your final chip cost will correspond to how big your chip ultimately is.
  

  

   
   

    IHP MWP price quotes:
    
     MPW Price Information 2026
    
   

  

  

   Yet, more area is not simply more expensive because of the direct manufacturing cost, there is a second more subtle factor inflating the price, and that is yield.
  

  

   Ultimately broken chips have no value, actually we could argue that we should ascribe negative value to broken chips because identifying which chips are broken costs money, and selling a customer a broken chip costs even more money. So maximizing the ratio of good chips to manufactured chips is of primary importance. This ratio is called the yield.
  

  

   Chips can be broken for a plethora of reasons, but for simplicity I will put them in two different buckets. Firstly it could be a design issue, in which case all your chips are equally affected. Secondly it could be a manufacturing defect that affects your chips semi-randomly.
  

  

   Manufacturing defects that occur during semiconductor device fabrication can be modeled as constant defect probability per unit of area, meaning that chips with higher area have a higher probability of having a defect, and thus lower yield, leading to ultimately higher costs.
  

  

   This doesn’t impact the price which I pay to the chip area per-se, but it affects the average net price that I will pay per functional chip.
  

  

   This is the double reason why area optimization is such a concern when designing chips.
  

  

   Now GlobaFoundaries 180nm (gf180) is not a young node, and the polite way of calling something old is
   
    “matrue”
   
   . With node maturity comes increased expertise of the process by the foundry leading to better yields over time. So gf180 is a node with excellent yields for which area related defects are not a concern especially compared to younger leading edge nodes.
  

  

   Wafer.space now offers 4 chip sizes, commonly referred to in the community as the “full”, “half”
   
    s
   
   and “quarter” slots.
  

  

   
   

    
     wafer.space
    
    pricing for run 2
   

  

  

   For people in need of some perspective, the full slot and its nearly 13mm2 of area is the same size as the entire Tiny Tapeout gf180 shuttle chip. The same chip that is capable of accommodating unto 160 project tiles and all the Tiny Tapeout common infrastructure. For reference, my two systolic arrays (8 bit integer and bfloat16) and the original switch all fit on only 4 tiles and my largest design to date, the blake2s hashing accelerator on 8.
  

  

   
   

    Run 2 wafers with the Tiny Tapeout chips in the middle on the left.
   

  

  

   Dicing
   
    
     #
    
   
  

  

   But getting the silicon manufactured is only the first battle of the war.
  

  

   Once you get your chip onto a wafer, there are two more important steps to clear before it can actually be called a chip.
  

  

   Semiconductors are manufactured on a substrate called a wafer, this is a solid silicon disk that then needs to be very precisely broken up into individual chips. This step is called dicing.
  

  

   So once the wafers have exited the fab and the guys at wafer.space take delivery of the full set of wafers, they call to another specialized service to dice them into individual chips along the scrible lines using a very precise diamond saw.
  

  

   
   

    Example of a cheap “mature” manual wafer dicer being sold at auction.
   

  

  

   At that point, wafer.space offers two possibilities. The first is to mail you the diced chips directly, the second is to get the chips packaged for you.
  

  

   Packaging ?
   
    
     #
    
   
  

  

   Raw semiconductor silicon is beautiful but unless you are also in the habit of collecting expensive crystals to look at, they are not much use as is. After all, how do you communicate with a piece of doped silicon crystal?
  

  

   
   

    
     FABulous FPGA
    
    raw die, part of the first wafer.space run.
   

  

  

   In order to both power our chip and be able to communicate with it, we need to package it in the form in which we can connect it to a wider electronic circuit.
  

  

   
   

    Micromaipulator probing station from the
    
     Balseiro Institute.
    
   

  

  

   That is, unless you just happen to have a micromanipulator and about 56 microprobes lying in your garage that you can use for chip bringup. In which case please do tell me if you ever need some help clearing out your garage, I have nothing planned that day.
  

  

   Chip packages come in different forms, the most common being some kind of black plastic enclosures used not only to create accessible connections to the silicon but also for protecting the delicate die and the connections from the environmental damage caused by shocks, humidity and extreme temperature fluctuations.
  

  

   The type of package we chose also affects how we architect the IO and thus what our silicon floorplan will look like. There are two big families of packages:
  

  
    
   
  • 
    wire bonded
   
    • 
   
  • 
    flip-chip
   
    • 
  

  

   
   

    source:
    
     https://anysilicon.com/flip-chip/
    
   

  

  

   In the case of flip-chips the IO pin connections will be spread out regularly all over the floorplan leading to shorter logic to pin connections, and supporting a greater pin density and count. But on the flip side (put intended), flip chips packaging requires a lot more precision and is more expensive compared to …
  

  

   Wire bonding works by conning your silicon to a pad in the package using a very thin fly wire made from gold or aluminium.
  

  
  
  

   This is done by a wire bonding machine that will physically pull a wire from a IO landing pad on the silicon and connect it to a landing pad on the package. The silicon would be placed at the center of the package and would be connected to the pads placed all around it on the package, themselves connected to the larger exterior pads.
  

  

   
   

    What do you mean it’s weird to spend my free time browsing
    
     Kyocera’s catalog
    
    of ceramic packages ? Just look at how cool they are.
   

  

  

   In this case the IO pad structures of the silicon would be located towards the exterior of the chip creating two distinct zones, the padring and the core region where most of the logic is located.
  

  

   There are many sub-flavors of wire bonded packaging, and wafer.space decided to offer something called chip-on-board packaging (CoB), which is a bit different to how mass market chips are classically packaged but also much more cost effective for small scale fabrication.
  

  

   
   

    Some of my own custom gold platted CoB PCBs. Here you have the PCB for a 56 pin part, and a 76 pin part both accommodating the quarter slot die size. The 56 pin PCB is a spin-off of the version wafer.space now uses and I had it manufactured in order to validate the manufacturability of the PCB changes I had made and was contributing back to the community.
   

  

  

   For CoB the chip is not bonded out to an enclosed package, but rather, the connections are made directly to a PCB.
  

  

   Once the chip has been bonded onto the PCB, a protective epoxy layer called a globtop is deposited and hardened on top of the silicon and the bonds. Some of you might have already noticed black blobs on commercial PCBs in the past, and without even realizing it you might have been looking at a CoB packaging.
  

  

   But unlike the dull black glob tops, wafer.space has opted for the rarer beautifully transparent epoxy, allowing you to directly see the chip bonded though the package.
  

  

   
   

    
     FABulous open source FPGA board
    
    made by Leo Moser, and manufactured as part of the first wafer.space run featuring the gorgeous CoB packaging.
   

  

  

   Take my money !
   
    
     #
    
   
  

  

   With your silicon bonded you now have what can officially be called a chip! 🥳
  

  

   What wafer.space is selling : the possibility for anyone to make their own full prototype chip run for the price of an expensive vacation, is honestly revolutionary.
  

  

   DARPA and google gave us the tools, Tiny Tapeout offered us a chance to sharpen our skills and wafer.space gave us direct access to manufacturing.
  

  

   Once more, in the spirit of transparency, I was invited onto the shuttle for free, but this sentiment comes from a genuine belief, so much so that as soon as the following manufacturing run sales opened I put my money where my mouth is, and bought my slot outright.
  

  

   
  

  

   Somehow this is still cheaper than flying back for Christmas.
  

  

   Chip architecture
   
    
     #
    
   
  

  

   If you are new here and this is your first time reading this blog, welcome.
  

  

   For those for whom this isn’t our first rodeo: you might be wondering how full chips differ from what I have been doing so far ?
  

  

   In previous episodes, I had been taping out my designs through Tiny Tapeout. Tiny Tapeout is a shuttle chip where multiple projects share the same chip, and in doing so share a common infrastructure. That infrastructure includes handling the silicon’s IO, the power and clock distribution as well as manufacturing and sticking the chip onto a functional development boards.
  

  

   
   

    
     Tiny Tapeout SKY 26c chip.
    
   

  

  

   All important parts that I now get the luxury of handling on my own, which also means I also get the luxury of making all the mistakes!
  

  

   But, after having gotten the chance to perfect my understanding and experience of the tapeout process through 9 prior Tiny Tapeout tapeouts this sounds the natural next step.
  

  

   With Tiny Tapeout, you don’t control the number of pins, nor do you have a precise idea of the timing of the signals arriving from the chip’s pins to the pins of your macro. Additionally, even though you can buy extra tiles on Tiny Tapeout, the smallest quarter slot chip on wafer.space still gives you more core area than the largest configuration of Tiny Tapeout has to offer.
And finally, Tiny Tapeout only gives you one chip per dev board, whereas with wafer.space you get a minimum order lot size of 1000 chips.
  

  

   Pins
   
    
     #
    
   
  

  

   For the purposes of the networking chip project, the real game changer is having control over the pin architecture, meaning I can now decide both the number and the type of the pins.
  

  

   Because I am comunicating with the PHY chip using an RMII interface, I care very much about pins as each Ethernet port interface requires 7 pins. This was also the reason why the initial version of the networking switch had only 3 ports: I only had 24 pins.
  

  

   You can refer to the previous article
   
    Designing an Ethernet Switch ASIC
   
   for an explanation on why each port needs 7 pins and each pin is used for.
  

  

   So now that I have a whopping 46 pins maximum to play with, we can get cooking!
  

  

   Anatomically pins are analog blocks with a landing pad for the wire bonded wire on one end. These are included as part of the GlobalFoundries open source foundry provided IO cell library, and although all the pins share the same height, width and landing pad sizes, each features different analog layouts according to its functionality.
  

  

   The most important types of pins for this design are the input pins, the bidirectional pins and the power delivery pins. Have fun playing spot the difference.
  

  

   Interestingly, the standard library does not offer any pure output pins, so outputs are handled by bidirectional pins statically configured in output mode.
  

  

   Looking at the floorplans provided above you might notice that these pins have no analog components directly under the landing pad, known as a “circuit under pad” design, making them a little less compact but more structurally resilient.
  

  

   This is because these pins were originally designed to be compatible with a version of the GlobalFoundary 180nm process with only 3 metalization layers, but multiple levels of a metal structure must be present between the top metal layer where the pad is and the analog circuit beneath in order to help isolate it from the force applied to the pad of wedge bonding. During wedge bonding the bond is physically pressed in place requiring applying a lot of force to the silicon and potentially leading to breakages in the circuits underneath if sufficient structural support pillars aren’t present.
  

  

   Padring
   
    
     #
    
   
  

  

   As discussed earlier, there are different families of packaging for chips resulting in different types of I/O design: flip-chips and wire bonding. Wire bonded chips such as mine have their pins facing the exterior of the chip organized in a structure called a pad ring.
This is a ring surrounding the core area of the chip, connecting all the different I/O pads together. This ring is used both for noise isolation and to share power between all the different pins. Because the padring is an uninterrupted crown of pins the space between the pins is filled by very simple structures called filler cells used to close the power connections within the ring.
  

  

   
   

    Render of the chip’s parding
   

  

  

   The IO also plays a crucial role in dealing with electrostatic discharge. (To whom many electronics have perished, including my little sister’s laptop that I may or may not have murdered while upgrading her ram when I was 15. 🪦 )
  

  

   Each pin contains structures that will act as forward biased diodes in the event of an electrostatic discharge steering the charge though the power rails and protecting the sensitive core logic.
  

  

   Power delivery
   
    
     #
    
   
  

  

   So we actually have four types of power delivery pins : two for ground and two for power.
  

  

   The difference between the two groups is that one is used to provide power to the IO itself and the other is used to power the chip’s core logic.
  

  

   Thus, it is possible to run the I/O and the internal design at different voltages. The areas for which a different power source is used is called a power domain. For example, the I/O could run at 5V, accepting 5V input signals and driving 5V outputs while internally the chip core runs the logic at 3.3V.
In this case, we would have different pins for powering the I/O and for powering the internal core. But, in the case of this networking chip, core power is shorted to IO power and both are in the same power domains.
  

  

   Such a setup is only made possible because the foundry provided 7 track standard cell library is, to put it mildly: rugged. The cell target operating range is between 1.62 and 5.5V voltage and -40 to 125C.
  

  

   So shorting the IO and core voltage and deciding to run the entire thing at 5V is just an average Tuesday.
  

  

   
┏━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━┓
┃                      ┃ Hold     ┃ Reg to   ┃          ┃          ┃ of which ┃ Setup     ┃ Reg to   ┃           ┃ Setup    ┃ of which  ┃          ┃           ┃
┃                      ┃ Worst    ┃ Reg      ┃          ┃ Hold Vio ┃ reg to   ┃ Worst     ┃ Reg      ┃           ┃ Vio      ┃ reg to    ┃ Max Cap  ┃ Max Slew  ┃
┃ Corner/Group         ┃ Slack    ┃ Paths    ┃ Hold TNS ┃ Count    ┃ reg      ┃ Slack     ┃ Paths    ┃ Setup TNS ┃ Count    ┃ reg       ┃ Violati… ┃ Violatio… ┃
┡━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━┩
│ Overall              │ 0.1951   │ 0.2897   │ 0.0000   │ 0        │ 0        │ -5.5684   │ -5.5684  │ -1272.41… │ 1065     │ 1060      │ 145      │ 2601      │
│ nom_tt_025C_3v30     │ 1.0471   │ 1.0471   │ 0.0000   │ 0        │ 0        │ 3.7457    │ 7.6040   │ 0.0000    │ 0        │ 0         │ 136      │ 1204      │
│ nom_ss_125C_3v00     │ 2.3477   │ 2.3477   │ 0.0000   │ 0        │ 0        │ -4.5534   │ -4.5534  │ -973.8862 │ 353      │ 352       │ 137      │ 2410      │
│ nom_ff_n40C_3v60     │ 0.4488   │ 0.4878   │ 0.0000   │ 0        │ 0        │ 4.6815    │ 12.7768  │ 0.0000    │ 0        │ 0         │ 136      │ 532       │
│ min_tt_025C_3v30     │ 1.0388   │ 1.0388   │ 0.0000   │ 0        │ 0        │ 3.7448    │ 8.0005   │ 0.0000    │ 0        │ 0         │ 130      │ 1149      │
│ min_ss_125C_3v00     │ 2.3336   │ 2.3336   │ 0.0000   │ 0        │ 0        │ -3.7267   │ -3.7267  │ -764.3782 │ 296      │ 295       │ 131      │ 2304      │
│ min_ff_n40C_3v60     │ 0.4466   │ 0.4826   │ 0.0000   │ 0        │ 0        │ 4.6844    │ 12.9664  │ 0.0000    │ 0        │ 0         │ 130      │ 481       │
│ max_tt_025C_3v30     │ 1.0579   │ 1.0579   │ 0.0000   │ 0        │ 0        │ 3.7465    │ 7.0758   │ 0.0000    │ 0        │ 0         │ 141      │ 1320      │
│ max_ss_125C_3v00     │ 2.3651   │ 2.3651   │ 0.0000   │ 0        │ 0        │ -5.5684   │ -5.5684  │ -1272.41… │ 416      │ 413       │ 142      │ 2601      │
│ max_ff_n40C_3v60     │ 0.4527   │ 0.4945   │ 0.0000   │ 0        │ 0        │ 4.6771    │ 12.4714  │ 0.0000    │ 0        │ 0         │ 140      │ 641       │
│ nom_tt_025C_5v00     │ 0.5200   │ 0.6317   │ 0.0000   │ 0        │ 0        │ 4.5785    │ 11.4278  │ 0.0000    │ 0        │ 0         │ 139      │ 673       │
│ nom_ss_125C_4v50     │ 1.1099   │ 1.3887   │ 0.0000   │ 0        │ 0        │ 3.5360    │ 4.4721   │ 0.0000    │ 0        │ 0         │ 139      │ 1444      │
│ nom_ff_n40C_5v50     │ 0.1981   │ 0.2942   │ 0.0000   │ 0        │ 0        │ 5.0271    │ 14.5140  │ 0.0000    │ 0        │ 0         │ 139      │ 249       │
│ min_tt_025C_5v00     │ 0.5113   │ 0.6248   │ 0.0000   │ 0        │ 0        │ 4.5846    │ 11.6500  │ 0.0000    │ 0        │ 0         │ 133      │ 648       │
│ min_ss_125C_4v50     │ 1.0892   │ 1.3768   │ 0.0000   │ 0        │ 0        │ 3.5474    │ 4.8628   │ 0.0000    │ 0        │ 0         │ 134      │ 1365      │
│ min_ff_n40C_5v50     │ 0.1951   │ 0.2897   │ 0.0000   │ 0        │ 0        │ 5.0285    │ 14.6577  │ 0.0000    │ 0        │ 0         │ 132      │ 223       │
│ max_tt_025C_5v00     │ 0.5316   │ 0.6407   │ 0.0000   │ 0        │ 0        │ 4.5719    │ 11.1135  │ 0.0000    │ 0        │ 0         │ 143      │ 784       │
│ max_ss_125C_4v50     │ 1.1382   │ 1.4034   │ 0.0000   │ 0        │ 0        │ 3.5178    │ 3.8667   │ 0.0000    │ 0        │ 0         │ 145      │ 1518      │
│ max_ff_n40C_5v50     │ 0.2026   │ 0.3003   │ 0.0000   │ 0        │ 0        │ 5.0257    │ 14.3356  │ 0.0000    │ 0        │ 0         │ 143      │ 449       │
└──────────────────────┴──────────┴──────────┴──────────┴──────────┴──────────┴───────────┴──────────┴───────────┴──────────┴───────────┴──────────┴───────────┘

  

  

   Example of a random timing report from another chip I am working on, with corners ranging from 3 to 5.5V and -40 to 125C. And again, this is still just a subset of all the corners there are: there are even more where this came from!
  

  

   For reference, this is just a tiny bit unusual.
  

  

   Most designs have separate power domains as modern nodes have cell libraries designed for much lower operating voltages in order to help reduce the area power density making cooling easier and to help optimize power consumption. In the case of leading edge nodes, internal logic targets operating voltages as low as 0.7 to 0.8 V. This forces having at least separate IO and core power domains, since your IO typically starts at 1.8V and above.
  

  

   Yet, you sometimes need separate power domains even if they operate at the same voltage, such as cases where you want to isolate a sensitive analog block from the power supply noise caused by a quickly toggling digital part. You might even prolong this separation of an analog and digital power domains to the IO, in which case rather than having a fully connected padring working within the same power domain you would be splitting the padding into analog IO power and digital IO power.
  

  

   Remember the filler cells I talked about earlier? Well there exists a special type of filler cell called a splitter used specially to split the pad ring in such cases. But, because of ESD concerns this splitter is not as simple as breaking the power line, but that is a discussion for another day.
  

  

   Clock and reset
   
    
     #
    
   
  

  

   The clock for this chip is supplied though a Schmitt trigger input pin and is strategically logged in the corner of the chip right next to the reset signal, and isolated from the rest of the pins by two power pins. This is done to limit the clock signal’s impact onto the neighboring pins given its toggle frequency, as well as to prevent the clock signal for the neighboring pins cross talk. The reset signal by comparison is a very stable signal producing little crosstalk of its own.
  

  

   From this point on the clock signal is pulled into the center of the floorplan and then distributed through a balanced clock tree throughout the chip.
  

  

   
   

    Render of the first level of the clock tree. The origin clock signal is colored in purpel and is feed from the bottom left pin
   

  

  

   Such “shielding” is even more important in our case since we are doing wire bonding and we can also have cross talk between signals occurring between the fly wires, this would be less of a problem for a flip-chip package.
  

  

   Zhe switch
   
    
     #
    
   
  

  

   This is a different challenge compared to what I was doing with Tiny Tapeout as I now have access to two great resources: firstly, a lot more pins to play with, and secondly, a lot more space.
Even if I target the smallest possible chip, I am still blessed with more area than I know what to do with.
  

  

   Even before being invited to contribute I was already eyeing the wafer.space slots, so selecting the switch at the crown project of the ASIC was the easy choice.
  

  

   The problem is that the switch was initially designed for the constraints of Tiny Tapeout. As such, not only does it have an odd architecture with only three ports, but it was designed to be as space efficient as possible. Here, space is something I am swimming in, but with only 96 hours ahead of me I have no time to redesign an entirely new switch from scratch.
So the plan is to re-adapt the existing switch to make the best use of being its own chip.
  

  

   The first and the most important change was to be able to make use of these abundant pins and have the switch to support more ports.
  

  

   No longer shall I be constrained by my pin count! 🔥 w 🔥
  

  

   … (Until I need more than 7 ports that is.)
  

  

   Parameters
   
    
     #
    
   
  

  

   Most of the verilog code you will see online tends to use hard coded widths like so :
  

  

   
module add(
	input wire [7:0] a_i, 
	input wire [7:0] b_i,
	output wire [7:0] res_o,
	output wire carry_o
);
	assign {carry_o, res_o} = a_i + b_i; 
endmodule

  

  

   What this code gains in ease of writing it loses in flexibility.
  

  

   In RTL, we have a concept called parameters, which exist for an instance of a module and allow you to define, at instantiation, certain values. These values can then be used to size up buses or are macro like conditions to define which sections of the code should be included in the final hardware.
  

  

   
module add#(
	parameter W = 8
)(
	input wire [W-1:0] a_i, 
	input wire [W-1:0] b_i,
	output wire [W-1:0] res_o,
	output wire carry_o
);
	assign {carry_o, res_o} = a_i + b_i; 
endmodule

  

  

   These generic values can then be inherited down the design hierarchy allowing dependent modules to be resized accordingly.
  

  

   Complexity
   
    
     #
    
   
  

  

   The original switch implementation was partially generic : it contained quite a few generic values, but these were mostly added out of habit to help clean up the design and keep things more readable, rather than truly making the design dimensions fully configurable.
  

  

   The reason for not making the design fully generic was out of a calculated decision to shy away from as much unnecessary complexity as possible. The original design was facing the hard physical constraints of Tiny Tapeout pin count, so making it fully generic to support an arbitrary amount of ports would have been an unnecessary premature optimization, and most importantly cost complexity.
  

  

   My grief against complexity comes from two calculated trade-offs.
  

  

   First, I find it is orders of magnitude cheaper to add complexity than to remove it.
  

  

   Secondly, complexity is especially expensive for hardware design because of the necessity to not have no have any bugs in the hardware. The only way of reaching this bug free state is through thought verification of operation under all possible scenarios. As we add complexity, we add hardware states such that the size of the space of states we need to explore grows exponentially.
  

  

   Now I know exponential growth might sound like an exaggeration, after all exponential growth is so fast that it is hard for our brains to conceive, but I assure you I am not.
  

  

   
   

    Illustration of exponential growth using the
    
     rice and the chessboard problem
    
    . If you double the quantity of grains of rice placed upon each square by the last square you would need \(2^{64}-1\) also known as \(18,446,744,073,709,551,615\) grains of rice.
   

  

  

   This problem is more formally called the “state explosion problem”.
  

  

   Scale Up
   
    
     #
    
   
  

  

   So the biggest change in the switch was to move the number of supported ports from a static three to a generic number.
  

  

   Even if the RTL scales, and I could theoretically run a simulation with 48 ports, the logic itself still has scaling limits. After all, behind the abstraction of the code we are designing hardware logic for which physical constraints still apply.
  

  

   As the structures get wider, the number of logic elements on a path increases, the paths get physically longer and the timing degrades. And so, with \(1.73mm^2\) of core area available, timing is the wall I hit first.
  

  

   Given the switch was already quite tight on timing, scaling it too far would push it beyond the limits of the current design requiring a rethink of the architecture. Rethink that I cannot afford to execute in so little time.
  

  

   Lastly, I said I was scaling the number of ports, but because of how tight the timings are on the switch lookup table already was, it is not getting scaled up. And because it still only has four entries, and scaling beyond four ports would result in too much contention on the table and not enough hits, it would not make any sense to go beyond 4 ports for now.
  

  

   Thus, I settled on four ports for the switch.
  

  

   Pin correspondance
   
    
     #
    
   
  

  

   Given I now control the full ASICs layout I can also control exactly which signal maps to which pin on the padring.
  

  

   
   

    Pin mapping of the first generation networking chip.
   

  

  

   Since the switch was intended to work with a specific Microchip family of external physical-layer chips, and that these chips had a known pinout, I decided to choose the pin order based on how directly I could draw the connecting wire onto the PCB.
  

  

   
   

    Pin layout of the LAN8720A(i) the external PHY chip containing the analog frontend for 100Mbps Ethernet
   

  

  

   Beacon
   
    
     #
    
   
  

  

   One of the best drawbacks of the switch scaling limit was that I was left with a few pins and lots of area to play with.
  

  

   And unlike with Tiny Tapeout where multiple projects share that same common infrastructure allowing only one project to be enabled at a time, this time I could have multiple designs working in parallel.
And I had just the perfect project to include in parallel.
  

  

   A few months back I did the two things the entire Internet knows not to do: firstly I asked Reddit for advice, secondly I followed it.
  

  

   
   

    
     A very serious request for reddit’s worst ASIC design ideas.
    
    Reddit did not disappoint.
   

  

  

   This project is called
   
    “Until Heat Death Do Us Part"
   
   and is a very serious implementation of an ethernet connected beacon that broadcasts its current time over 100 Mbit Ethernet with the ability to do so without overflow for the next \(10^{100}\) years. Also believed to be roughly the estimated heat death of the universe, give or take a few powers of 10 years.
  

  

   I have a full write-up about this ASIC’s here for those interested in getting the full story:
   
    Until Heat Death Do Us Part.
   
  

  

   Full chip
   
    
     #
    
   
  

  

   
   

    Full chip floorplan render.
   

  

  

   Putting it all together: this chip features two designs, the 4 port 100Mbps networking switch and the ethernet broadcast beacon. The networking switch is the denser design on the right hand side of the floorplan with the beacon being the on the left side, each designed placed next to there respective port pins.
  

  

   What comes next?
   
    
     #
    
   
  

  

   It’s already been a few months since the chip has been sent to the fab. Since then the first batch of produced wafers have exited the fab and been received by the wafer.space.
  

  

   Andrew Wingate shared with us some absolutely gorgeous pictures of the diced wafers, and there is my little chip in the flesh sitting on the top right corner of the reticle:
  

  

   
   

    Networking chip die shot taken on the wafer
   

  

  

   The dies are then picked off the diced wafer using a custom built robot and sorted per chip type into a tape reel. From there the chips will be either sent to the bond house for packaging or directly sent to the customer.
  

  

   
   

    Andrew Wingate’s custom die sorting robot. Sometimes if you don’t have it just build it. On that note Andrew runs
    
     evezor
    
    a small robotic company where you can find the base kit for this robot
   

  

  

   And now I am like a child waiting for Christmas, impaciently awaiting a package, inside the first batch of my own full custom ASIC chips.
  

  

   Now, the chip doesn’t make a full networking equipment on its own, which is why I am also prototyping a PCB for the switch. Hopefully someday I can plug the chip in to get a fully functional switch.
  

  

   
   

    From the perspective of my husband coming back home, or what ‘I spent the day in the kitchen’ actually looks like.
   

  

  

   Here is to hoping the first iteration of the silicon just works !
  

  

   .. which anyone working in the industry can attest to, A0s are rare enough to be legendary.
  

  

   
    
     
      
      
     
    
   
   
    

     Manufacturing revisions of a chip are identified by a letter followed by a number.
    

    

     A0 is the first iteration, minor revision such as changing some of the higher metalization layers will increment the number and major revisions requiring a new mask set for the bottom layers, where the transistors are built, increment the letter and reset the number. So revisions might go: A0, A1, A2, B0, B1, B2, B3, C0, etc…
    

   
  

  

   Meanwhile the networking equipment project continues, chasing after building increasingly complex systems. Without going too deep into which next networking features I want to add, it is becoming quickly apparent that I will need to integrate some form of a CPU.
  

  

   This is because as I target more advanced networking applications the tasks my silicon needs to accomplish become increasingly varied and start featuring a large array of tasks that occur rarely enough, and have sufficiently lax performance requirements to be better suited for software than hardware.
  

  

   As for the matter of which CPU architecture to choose, although RISC-V is in vogue I find that, as a result of RISC-V’s architectural choices, it is just too expensive to implement in terms of area for systems like mine.
  

  

   
   

    Floorplan of a RSIC-V Hazard3 core with JTAG accessible debug infrastructure occupying 700x700 um of area on gf180 implemented during my planning of the next chip’s architecture. It is worth noting that since we do not have any silicon proven macros for a 16x32 or 32x32 register file I am implementing it using scan dff gates, resulting in an even worse area. Credit goes to Luke Wren for the idea of using the scan flops to make up for the absence of an flop with enables in the gf180 standard cell library.
   

  

  

   My needs when selecting witch CPU architecture to use are:
  

  
    
   
  • 
    be cheap to implement in hardware
   
    • 
   
  • 
    have a pre-existing software ecosystem, meaning having C compiler and debugger support
   
    • 
   
  • 
    not get me sued
   
    • 
  

  

   If only gcc were to maintain something like the “Status of Supported Architectures from Maintainers’ Point of View” at
   
    https://gcc.gnu.org/backends.html
   
   then maybe I could know what my options where.
  

  

   
Architecture characteristic key
-----------------------------------------------------------------------
H       A hardware implementation does not exist.
M       A hardware implementation is not currently being manufactured.
S       A Free simulator does not exist.
L       Integer registers are narrower than 32 bits.
Q       Integer registers are at least 64 bits wide.
N       Memory is not byte addressable, and/or bytes are not eight bits.
F       Floating point arithmetic is not included in the instruction set
I       Architecture does not use IEEE format floating point numbers
C       Architecture does not have a single condition code register.
B       Architecture has delay slots.
D       Architecture has a stack that grows upward.

l       Port cannot use ILP32 mode integer arithmetic.
q       Port can use LP64 mode integer arithmetic.
r       Port can switch between ILP32 and LP64 at runtime.
        (Not necessarily supported by all subtargets.)
p       Port uses define_peephole (as opposed to define_peephole2).
b       Port uses '"* ..."' notation for output template code.
f       Port does not define prologue and/or epilogue RTL expanders.
m       Port does not use define_constants.
g       Port does not define TARGET_ASM_FUNCTION_(PRO|EPI)LOGUE.
i       Port generates multiple inheritance thunks using
        TARGET_ASM_OUTPUT_MI(_VCALL)_THUNK.
a       Port uses LRA (by default, i.e. unless overridden by a switch).
t       All insns either produce exactly one assembly instruction, or
        trigger a define_split.
e       <arch>-elf is not a supported target.
s       <arch>-elf is the correct target to use with the simulator
        in /cvs/src.

          |      Characteristics
Target     | HMSLQNFICBD lqrpbfmgiates
-----------+--------------------------
aarch64    |     Q        q  b  gia  s
alpha      |  ?  Q   C    q    mgi  e
arc        |          B      b  gia
arm        |                 b   ia  s
avr        |    L  FI    l  p   g a
bfin       |       F            gi
bpf        | HM  Q FIC   lq  b    a
c6x        |   S     CB         gi
cris       |       F  B         gia  s
csky       |                 b   ia
epiphany   |         C          gia  s
fr30       | ??    FI B     pb mg    s
frv        | ??       B      b   i   s
gcn        |   S     C D  q       a e
h8300      |       FI B         g a  s
i386       |     Q        q  b   ia
ia64       |   ? Q   C    qr b m i
iq2000     | ???   FICB      b  g at
lm32       |       F            g
m32c       |    L  FI    l   b  g    s
m32r       |       FI        b    a  s
m68k       |                pb   i
mcore      |  ?    FI       pb mg    s
mep        |       F C       b  g  t s
microblaze |         CB          ia  s
mips       |     Q   CB   qr     ia  s
mmix       | HM  Q   C    q      ia e
mn10300    | ??                 gi   s
moxie      |       F            g  t s
msp430     |    L  FI    l   b  g    s
nds32      |       F C           ia  s
nios2      |         C           ia
nvptx      |   S Q   C    q    mg   e
pa         |     Q   CBD  qr b   i  e
pdp11      |    L   IC    qr b      e
pru        |    L  F              a  s
riscv      |     Q   C    qr    gia
rl78       |    L  F     l      g    s
rs6000     |     Q   C    qrpb   ia
rx         |                         s
s390       |     Q        qr    gia e
sh         |     Q   CB   qrp    i
sparc      |     Q   CB   qr b   ia
stormy16   | ???L  FIC D l   b   ia
v850       |                    g a  s
vax        |  M     I        b   i  e
visium     |          B         g  t s
xtensa     |         C

  

  

   Behold: so many beautiful options supported that most people have never even heard of!
  

  

   And within this list there is one 16 bit architecture that caught my eye, at the heart of one of the longest produced systems and deeply intertwined with computer history as it saw the first version of Unix written in C.
  

  

   What better choice than a PDP-11?
  

  

   Closing
   
    
     #
    
   
  

  

   A year ago, I started on a journey to go from being solely a hardware designer to building an entire ASIC from scratch without any institutional backing.
  

  

   It’s been a long road, passing though multiple smaller macro tapeouts, each allowing me to delve deeper into what it takes to make ASICs. This chip is my 10th solo tapeout, a fitting number to finally graduate into building full chips.
  

  

   Standing upon this mountain I can tell you the road ahead is still very long.
  

  

   And with my first batch of full custom ASICs landing into my mailbox in a few weeks a new risk has emergeded, leading me to proclaim a new goal: not starting a fabless semiconductor company.
  

  

   
   

    Tradional celebratory Waffle House.
   

  

  

   
    Current life goals
   
  

  
    
   
  • 
    Have kids
   
    • 
   
  • 
    Spend time with loved ones
   
    • 
   
  • 
    Make chips
   
    • 
   
  • 
    Eat waffles
   
    • 
   
  • 
    Get a wire bonder
   
    • 
   
  • 
    Not get a job
   
    • 
   
  • 
    Not startting a fabless semiconductor company 🆕
   
    • 
  

  

   Thanks again to wafer.space for giving me this opportunity to join the shuttle, Tiny Tapeout for making the 9 previous tapeouts possible and the open source silicon community for building the tools making all of this possible.
  

  

   If you enjoyed this, I will be sipping coffee at a Silicon Valley neighborhood cafe between the 10th and 12th of November, so if you feel like nerding out over caffeine shoot me an
   
    email
   
   .
  

 




        

      

    
    

        

          
Nvidia and Jensen Huang sued by shareholders over affair with alleged Chinese spy

        

        

          Guardian
        

	

	  www.theguardian.com
	

        

          2026-11-10 02:30:15
        

        

          
          

            Legal action comes as Donald Trump says FBI is investigating tech company CEO’s links with Alice HuangBusiness live – latest updatesNvidia’s board needs to do some succession planning – sharpishNvidia and its chief executive, Jensen Huang, have been accused of defrauding shareholders in a lawsuit ov...
          

        

        

          
Original Article

          

 

  

   Nvidia and its chief executive,
   
    Jensen Huang
   
   , have been accused of defrauding shareholders in a lawsuit over the Chinese spying scandal engulfing the $4.3tn (£3.2tn) company.
  

  

   The legal action came as Donald Trump said the FBI was investigating Huang’s affair with an alleged Chinese spy.
  

  

   According to a complaint filed in federal court in ​California,
   
    Nvidia
   
   and Huang misled shareholders in connection with the executive’s alleged ​affair with Alice Huang, a former executive of Singapore-based ⁠Megaspeed who is not related to him.
  

  

   
   
  

  

   The shareholders claim both parties did ​not disclose that the matter raised national security concerns that threatened Nvidia’s reputation and business prospects.
  

  

   The New York Times reported on the alleged relationship last month, and said US authorities had concluded Alice Huang ​was a Chinese intelligence asset.
  

  

   Nvidia did not immediately respond to ​a request for comment.
  

  

   Jensen Huang
   
    told Nvidia’s employees
   
   he had been unfaithful to ‌his ⁠wife, without disclosing details of the alleged relationship.
  

  

   He co-founded Nvidia in 1993 and has led the California company as it became the world’s most valuable chipmaker and made him ​one of the ​world’s most ⁠prominent symbols of the artificial intelligence boom.
  

  

   
    
     skip past newsletter promotion
    
    
   
  

  

   
   
  

  

   Nvidia announced on Sunday it was conducting an independent investigation into reports that Huang was the “target of a foreign intelligence effort”. Shares in the company tumbled on Monday, closing down 4.3%, reducing Nvidia’s ​market ⁠value by approximately $190bn. The lawsuit was filed five minutes after the US stock market closed.
  

  

   It is common for shareholders to ⁠sue ​companies after unexpected share price declines. ​Nvidia shareholders, led by Mark Kistenmacher, a retail investor, are seeking unspecified damages from the defendants.
  

  

   
    

     

      
       
        
        
       
      
      
       Trump backs embattled Hegseth and Jensen Huang and says FBI looking into spy allegations – video
      
     

    

   
  

  

   Trump said on Monday that the FBI is investigating Huang’s affair but said he does not think the executive has a reason to worry.
  

  

   “I know the FBI is looking into it in terms of something else, and I think that he’ll be in good shape,” Trump said at a White House briefing.
  

  

   “I did speak to him today just to see if he’s feeling all right, how you’re doing,” Trump said. “He said he had absolutely no idea that the person in question was a spy.”
  

  

   Huang said in an open letter posted on Nvidia’s website: “I support the investigation and will cooperate fully. I love our country and our company. I am committed to protecting Nvidia and supporting America’s national security,”
  

  

   
    Reuters contributed to this report
   
  

 




        

      

    
    

        

          
Introducing Our Smallest, Most Efficient Model: Muse Ember

        

        

          Simon Willison
        

	

	  simonwillison.net
	

        

          2026-11-10 02:28:21
        

        

          
            

          
          

            Introducing Our Smallest, Most Efficient Model: Muse Ember
Meta AI just launched their entry in the Claude Haiku/GPT Luna category: Muse Ember, which they describe as:

[...] our smallest and most efficient model designed for complex reasoning execution and the work agents repeat all day: tool calls...
          

        

        

          
Original Article

          

 

  

   
    
     Introducing Our Smallest, Most Efficient Model: Muse Ember
    
   
   . Meta AI just launched their entry in the Claude Haiku/GPT Luna category: Muse Ember, which they describe as:
  

  

   

    [...] our smallest and most efficient model designed for complex reasoning execution and the work agents repeat all day: tool calls, coding subtasks, routing, extraction, and long document parsing.
   

  

  

   For shorter prompts it's priced the same as GPT-6 Luna and Claude Haiku 5.5 - both are $0.10/million input tokens and $0.50/million output. Today's other big model release, Claude Fable 5.2, is
   
    80x that price
   
   at $8/$40.
  

  

   The pricing is a little less straightforward as prompts get longer, though. Luna, Ember, and Haiku all support up to a million input tokens, but they also all have a threshold after which the price goes up. Taking
   
    that
   
   threshold into account Ember is priced between the two others:
  

  

   

    
     

      
       Model
      
      
       Prompt size
      
      
       Input ($/M)
      
      
       Cached input
      
      
       Output
      
     

    
    
     

      
       GPT-6 Luna
      
      
       ≤272k
      
      
       $0.10
      
      
       $0.01
      
      
       $0.50
      
     

     

      
       >272k
      
      
       $0.20
      
      
       $0.02
      
      
       $0.75
      
     

     

      
       Muse Ember 1.0
      
      
       ≤200k
      
      
       $0.10
      
      
       $0.004
      
      
       $0.50
      
     

     

      
       >200k
      
      
       $0.30
      
      
       $0.012
      
      
       $1.50
      
     

     

      
       Claude Haiku 5.5
      
      
       ≤100k
      
      
       $0.10
      
      
       $0.01
      
      
       $0.50
      
     

     

      
       >100k
      
      
       $0.50
      
      
       $0.05
      
      
       $2.50
      
     

    
   

  

  

   But comparing price-per-token doesn't really make sense these days, when reasoning tokens mean that different models might use dramatically different numbers of tokens to solve the same problem.
  

  

   For that, one measure that's useful is the Artificial Analysis.
  

  

   Stacked bar chart from Artificial Analysis comparing a cost in dollars across six models, each bar split into four unlabeled stacked segments, sorted from lowest to highest total. Claude Haiku 5.5 (low): $0.04* total, bottom segment $0.02, three thin unlabeled segments above. GPT-6 Luna (non-reasoning): $0.07 total, bottom segment $0.06, thin unlabeled segments above. GPT-6 Luna (xhigh): $0.10 total, segments from bottom $0.07, $0.02, $0.02, plus a thin unlabeled top segment. Muse Ember (xhigh): $0.12 total, segments from bottom $0.06, $0.02, $0.02, plus a thin unlabeled top segment. Muse Ember (max): $0.14 total, segments from bottom $0.07, $0.03, $0.03, $0.02. Claude Haiku 5.5 (xhigh): $0.25* total, segments from bottom $0.14, $0.04, $0.05, $0.02. Anthropic bars are terracotta, OpenAI bars are dark gray, Meta bars are blue, each with the company logo beneath.
  

  

   And even more useful than that is their Intelligence Index vs. Cost per Task chart, which shows the following for those three models:
  

  

   Scatter plot from Artificial Analysis titled "Intelligence Index vs. Cost per Task", plotting Artificial Analysis Intelligence Index (y-axis, 5 to 40) against cost per task in USD on a log scale (x-axis, $0.04 to $0.3), with a green "most attractive quadrant" in the upper left and a dotted Pareto line. Claude Haiku 5.5 (low)* scores about 19 at roughly $0.044. GPT-6 Luna (non-reasoning) scores about 9.5 at roughly $0.07. GPT-6 Luna (xhigh) scores about 23.5 at roughly $0.10. Muse Ember (xhigh) scores about 34 at roughly $0.12 and Muse Ember (max) about 36 at roughly $0.14, both on the Pareto line. Claude Haiku 5.5 (xhigh)* scores about 34.5 at roughly $0.25, well to the right of the Pareto line. Three unlabeled gray dots also sit on the Pareto line.
  

  

   The Muse Ember models sit right on that Pareto line - the line at which you can only improve one dimension by giving up another. Meta call this out in their announcement:
  

  

   

    It also sits on the efficiency frontier of the full Artificial Analysis leaderboard: no model scores higher for less per task.
   

  

  

   (That grey dot on the Pareto line in the middle of the green area is GPT-6.1 Terra (low) - clearly I should be paying more attention to the Terra family!)
  

  

   Muse Ember has six reasoning levels - minimal, low, medium, high, xhigh, and max - so I
   
    rendered six pelicans riding bicycles
   
   . The "high" reasoning level failed to return a full SVG, and the other SVGs were surprising in that the reasoning level didn't cleanly map to the visual quality of the response.
  

  

   Here's the "max" one, but the others are worth a look too:
  

  

   Bicycle frame is OK, basket has fish, pelican has a weird blue hat on.
  

  

   The Ember pelicans are comparable in quality to those
   
    I got from Muse Wonder
   
   , which is
   
    40x the price
   
   of Muse Ember.
  

 




        

      

    
    

        

          
Fireworks AI security breach impacts Notion and their customers

        

        

          Hacker News
        

	

	  www.notion.com
	

        

          2026-11-10 02:19:38
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   

   

  

  

   

    

     
      
       Jump to FAQs
      
     
    

   

   

   

    

     

      This notice is about the security incident at one of our vendors, Fireworks AI, that may impact some Notion workspaces. For the latest on the Fireworks AI incident, see their
      
       
        official security updates here
       
      
      .
     

     

      Following an investigation by the Notion security team, we have determined that <1% of Notion workspaces may have been affected by the Fireworks security incident. Some unattributable chat sessions with Notion AI may have been exposed in this incident. “Unattributable” means the chats weren't labeled with who wrote them or which workspace they came from, and the transcripts did not contain tool call results. Beyond what’s in the chat transcript itself, there’s no information tying the chat back to a workspace, user, or company. No other data from within the workspace is affected.
     

     

      

       

        
         What is Fireworks AI and how we used them
        
       

      

     

     

      Fireworks is one of the most-used global AI infrastructure platforms powering tens of thousands of customers, and used by hundreds of thousands of developers. We used Fireworks for classification jobs to help customers understand their own AI usage through a feature in Notion called
      
       
        Insights
       
      
      , and we used them as a general inference provider to serve open-weight models inside our product. The Insights feature has been disabled as we investigate this incident, and we are no longer serving open-weight models through Fireworks.
     

     

      

       

        
         What happened and how we addressed it
        
       

      

     

     

      We learned from Fireworks about potential incidents earlier this month, and we shut down all connections to their systems out of an abundance of caution.
     

     

      On November 6, Fireworks notified us that malicious actors may have accessed potential customer data. Our team immediately began another internal investigation. On November 8, Fireworks confirmed this new dataset for us.
     

     

      Upon analysis of the new data, we discovered that it included unattributable Notion AI chat transcripts used for the Insights feature. Chats weren't labeled with who wrote them or which workspace they came from, and the transcripts did not contain any tool call results. Beyond the words in the chat transcripts themselves, the data contained no information that could specifically identify the workspace, user, or company.
     

     

      No other Notion data from your workspace is affected, and we continue to monitor this incident.
     

     

      
       If neither you nor your workspace owner has heard from us, that means your workspace is not affected, and no action is needed right now.
      
     

     

      For the workspaces impacted by the Fireworks AI incident (<1% of the Notion workspaces), we have contacted the workspace owners. Affected customers will be able to retrieve and review the affected data securely inside their workspace.
     

     

      For the workspaces affected by the Fireworks AI incident, workspace owners can view the affected data by going to their workspace sidebar →
      
       ?
      
      →
      
       Security incident review
      
      . To view this data, use the desktop app or a web browser and make sure you’re on the latest version of Notion. This data is not accessible on mobile.
     

     

      

       

        Workspace owners on Enterprise plans can access:
       

      

     

     

      
    
       
  • 
        
    
         A CSV of your workspace’s data affected by the incident. Only workspace owners can see this data.
        
    
       
    • 
       
  • 
        
    
         An annotated CSV of the same affected workspace data with additional metadata, such as the user associated with each chat transcript, to help you understand and run your own analysis of the impact. These added annotations and metadata were not exposed as part of the incident. Additional annotated fields are marked with
         
          __metadata
         
         or
         
          __analysis
         
         respectively. Only workspace owners can see this data.
        
    
       
    • 
       
  • 
        
    
         
          Note:
         
         These resources are only available if you have managed members for your workspace. Reach out to your account team if you have questions.
        
    
       
    • 
      

     

     

      

       

        Workspace owners on all other plan types can access:
       

      

     

     

      
    
       
  • 
        
    
         A page that includes a link they can share with affected members to review their own data.
        
    
       
    • 
      

     

     

      

       

        For other workspace roles:
       

      

     

     

      
    
       
  • 
        
    
         Workspace owners can provide a link to members so members can see their own affected data.
        
    
       
    • 
       
  • 
        
    
         Once shared, the link will provide members with a CSV of
         
          only the member's own data
         
         affected by the incident.
        
    
       
    • 
      

     

     

      
       We recommend that you treat this data as if it were exposed.
      
      If you or anyone on your team pasted sensitive information like passwords, API keys, or other credentials into Notion AI during this timeframe, we recommend rotating them right away.
     

    

   

   

   

    

     

      FAQs
     

    

    

     

      

       
        

         What is Fireworks and how did Notion use them?
        

       
       

        

         

          
           
            Fireworks AI
           
          
          is one of the most used global AI infrastructure platforms powering tens of thousands of customers and used by hundreds of thousands of developers.
         

         

          As of November 3rd, we have disconnected our systems from Fireworks, deleted all data in the Fireworks system, and stopped sending all data and traffic to Fireworks. We have also halted all training runs.
         

         

          We previously used Fireworks for classification jobs to help customers understand their own AI usage through a feature in Notion called
          
           
            Insights
           
          
          and as a general inference provider to serve open-weight models inside our product.
         

        

       

      

      

       
        

         What does “unattributable” mean? Could the conversations still contain sensitive information?
        

       
       

        

         

          Following an investigation by the Notion security team, we have determined that <1% of Notion workspaces may have been affected by the Fireworks security incident. Some unattributable chat sessions with Notion AI may have been exposed.
         

         

          "Unattributable" means the chats weren't labeled with who wrote them or which workspace they came from. The transcripts also did not contain tool call results (e.g., Notion page content, or external data pulled in by Notion AI.) Beyond what’s in the chat transcript itself, there’s no information tying the chat back to specific workspaces, users, or companies. No other data from within your workspace is affected.
         

         

          As a precaution, we recommend that you treat this unattributable data as if it were exposed. If anyone on your team pasted sensitive information like passwords, API keys, or other credentials into Notion AI during this timeframe, we recommend rotating them right away.
         

        

       

      

      

       
        

         How did Notion use Fireworks with the Learning and Early Access Program (LEAP)?
        

       
       

        

         

          Customers in the
          
           
            Learning and Early Access Program
           
          
          (LEAP) volunteer their data to help Notion test new AI technology. In the past, we used this volunteered data to experiment with training task-specific models on Fireworks.
         

        

       

      

      

       
        

         Where can I learn more about Notion’s security practices?
        

       
       

        

         

          Visit our
          
           
            Security page
           
          
          for an overview of Notion’s security and privacy practices. For more information on security policies, security audit reports, penetration test results, and additional resources, visit the
          
           
            Notion Trust Center
           
          
          .
         

        

       

      

     

    

   

  

 




        

      

    
    

        

          
Apple MacBook Pro review: lighter, thinner and a stunning OLED touchscreen

        

        

          Guardian
        

	

	  www.theguardian.com
	

        

          2026-11-10 02:00:31
        

        

          
            

          
          

            Redesigned flagship laptop has a fantastic display, killer performance and the first touchscreen on a Mac, but comes with a serious price tag Apple’s MacBook Pro has been redesigned for the first time in five years, getting slightly slimmer, significantly lighter and adding a fantastic new OLED disp...
          

        

        

          
Original Article

          

 

  

   Apple’s MacBook Pro has been redesigned for the first time in five years, getting slightly slimmer, significantly lighter and adding a fantastic new OLED display with the first touchscreen on a Mac.
  

  

   The new MacBook Pro with PROLED XDR display comes in two sizes, 14in and 16in, but rather than replacing the standard MacBook Pro they sit alongside them as an even more expensive option. The OLED machines start at £2,899 (€3,299/$2,899/A$4,599) – a £400 or equivalent upgrade on the matching spec LCD models – serious prices for serious work machines, not helped by significant cost increases driven
   
    by RAMageddon
   
   .
  

  

   Shut, the new OLED MacBook Pro looks almost identical to its predecessors: a little smaller in every direction but with the same aluminium body, combination of ports and overall profile. But pick it up and the weight loss is immediately noticeable. The 14in version is 14% lighter than its predecessor at 1.38kg, which makes it only 150g heavier than the
   
    13in MacBook Air
   
   , and the 16in version is 15% lighter at 1.82kg.
  

  

   

    
     
     
     
     
     
     
     An new Apple MacBook Pro partially open showing its lid with a glowing Apple logo
    
   

   

    
     
      
      
     
    
    
     The glowing Apple logo on the lid is back having once been a mainstay of the company’s laptops until 2015.
    
    Photograph: Samuel Gibbs/The Guardian
   

  

  

   The new touchscreen is the biggest change, complete with the dynamic island around the web cam
   
    like a modern iPhone
   
   . The screen on the
   
    LCD MacBook Pro was already fantastic
   
   , but the switch to OLED has several benefits. The screen is even brighter, hitting an incredible peak of 2,000 nits for outdoor or HDR content viewing, making it one of the brightest laptop screens available.
  

  

   OLED displays have individually lit pixels, which gives them dramatically better contrast with the deepest blacks and eliminates any blooming effects. That makes the new screen one of the very best on any product and a genuine joy to use to create or watch content. It is super crisp, vibrant and smooth, and makes the most of dark mode.
  

  

   

    
     
     
     
     
     
     
     Apple MacBook Pro with 16in PROLED XDR display showing the dynamic island and Siri
    
   

   

    
     
      
      
     
    
    
     The dynamic island at the top of the screen shows music playback, timers and live activities such as sport scores, while acting as Siri’s new home, too.
    
    Photograph: Samuel Gibbs/The Guardian
   

  

  

   Specifications
  

  
    
   
  • 
    
    
     
      14in
     
     
      screen
     
     
      :
     
     14.2in tandem OLED (3024x1986; 254 ppi) ProMotion (10-120Hz)
    
    
   
    • 
   
  • 
    
    
     
      16in screen
     
     
      :
     
     16.3in tandem OLED (3472x2266; 254 ppi) ProMotion (10-120Hz)
    
    
   
    • 
   
  • 
    
    
     
      Processor:
     
     Apple M5 Pro or Max
    
    
   
    • 
   
  • 
    
    
     
      RAM:
     
     24, 36, 48, 64 or 128GB
    
    
   
    • 
   
  • 
    
    
     
      Storage:
     
     1, 2, 4, 8 or 16TB SSD
    
    
   
    • 
   
  • 
    
    
     
      Operating system:
     
     macOS 27.2
    
    
   
    • 
   
  • 
    
    
     
      Camera:
     
     12MP Centre Stage
    
    
   
    • 
   
  • 
    
    
     
      Connectivity:
     
     wifi 7, Bluetooth 6, Thread, 3x Thunderbolt 5/USB 4, HDMI 2.1, SDXC card, headphones
    
    
   
    • 
   
  • 
    
    
     
      14in dimensions
     
     
      :
     
     216.3 x 310.8 x 15mm
    
    
   
    • 
   
  • 
    
    
     
      14in
     
     
      weight
     
     
      :
     
     1.38 to 1.4kg
    
    
   
    • 
   
  • 
    
    
     
      16in
     
     
      dimensions
     
     
      :
     
     244.2 x 355.5 x 16mm
    
    
   
    • 
   
  • 
    
    
     
      16in
     
     
      weight
     
     
      :
     
     1.82 to 1.84kg
    
    
   
    • 
  

  

   Reach out and touch me, sometimes
  

  

   

    
     
     
     
     
     
     
     Apple MacBook Pro with 16in PROLED XDR display showing expanded traffic lights as a finger attempts to close a window using the touchscreen
    
   

   

    
     
      
      
     
    
    
     Tapping on areas such as the window traffic lights expands them so you can tap on the right button.
    
    Photograph: Samuel Gibbs/The Guardian
   

  

  

   The OLED MacBook Pro isn’t the first laptop with a touchscreen – they’ve been common on Windows laptops since 2012 – but it is the first Mac with one. For the most part the touchscreen mirrors mouse clicks, so you can single tap on just about anything or tap and hold for right click on most things.
  

  

   It also supports most of the gestures available on a trackpad, including swipes, pinch to zoom and rotate. Three-finger swipes trigger mission control so you can switch between windows, while flicking them left or right snaps them to the screen’s edge – though unsnapping them requires a mouse for some reason. Swipe in from the right side of the screen for notification centre, down from the top right for control centre and from the dynamic island for Spotlight or Siri.
  

  

   

    
     
     
     
     
     
     
     The iPhone mirroring feature being used on an Apple MacBook Pro with 16in PROLED XDR display gripped by a hand on the screen
    
   

   

    
     
      
      
     
    
    
     The iPhone mirroring feature is far better using the touchscreen than a mouse, as could be testing iPhone or iPad apps directly on the screen with a finger for developers.
    
    Photograph: Samuel Gibbs/The Guardian
   

  

  

   The Mac is not touch-first like an iPad and there is no touchscreen keyboard. But Apple has built new touch systems that third-party app developers can use to do unique things, such as tools that fan out around your finger or scrubbing dials. Those are few and far between at the moment.
  

  

   That leaves touching the screen an optional extra. Like Windows machines, it is handy to have direct interaction with something using your finger sometimes. Pinch to zoom or rotating a photo is a lot easier directly on the screen than the touchpad, as is tapping the screen to pause video. The touchscreen is also useful for performing various gestures if you use a mouse rather than a trackpad.
  

  

   A choice of M5 Pro or Max
  

  

   

    
     
     
     
     
     
     
     The ports of the Apple MacBook Pro with 16in PROLED XDR display
    
   

   

    
     
      
      
     
    
    
     The MacBook Pro has three USB-C/Thunderbolt 5 ports, an HDMI port, an SD card reader and a headphones socket.
    
    Photograph: Samuel Gibbs/The Guardian
   

  

  

   The OLED MacBook Pros come with the same M5 Pro or Max chips and memory choices as the regular MacBook Pros with essentially the same performance in benchmarks and during general use. They also have similar battery life, lasting for about two days of office work while mainly using the browser, writing, messaging and note-taking tools.
  

  

   For more intensive workloads, such as developing and editing photos or other mid-level creative apps, the 16in version with M5 Max still managed to end the day with 40% left in the tank. If pushed to the limit, the battery lasts about two hours, which is still long enough to get a solid task or two done when away from the charger.
  

  

   Sustainability
  

  

   

    
     
     
     
     
     
     
     The keyboard, trackpad and deck of the Apple MacBook Pro with 16in PROLED XDR display
    
   

   

    
     
      
      
     
    
    
     The excellent keyboard and generous trackpad offer the same first-class experience as previous MacBook Pros, while the speakers are best-in-class for a laptop and really very good.
    
    Photograph: Samuel Gibbs/The Guardian
   

  

  

   The MacBook Pro OLED is made of 55% recycled materials, which Apple breaks down in its
   
    environmental impact report
   
   . The battery should last in
   
    excess of 1,000 full charge cycles
   
   and can be
   
    replaced for £225 by Apple
   
   . Apple makes
   
    repair manuals available
   
   , offers trade-in and free recycling schemes.
  

  

   Price
  

  

   The MacBook Pro with PROLED starts at
   
    £2,899
   
   (€3,299/
   
    $2,899
   
   /
   
    A$4,599
   
   ) for the 14in version or £3,399 (€3,899/$3,399/A$5,499) for the 16in version.
  

  

   For comparison, the 14in M6 MacBook Pro costs
   
    £1,999,
   
   the
   
    14in M5 Pro MacBook Pro
   
   costs
   
    £2,499
   
   , the
   
    13in MacBook Air
   
   costs
   
    £1,299
   
   , the Dell XPS 14 costs from
   
    £2,038.45
   
   and the Microsoft Surface Laptop Ultra costs
   
    £2,599
   
   .
  

  

   Verdict
  

  

   The OLED MacBook Pro might be the first touchscreen Mac, but touch is the least interesting part about it.
  

  

   The reduced weight, slimmer body and absolutely stunning new screen are meaningful upgrades that will no doubt see the MacBook Pro through another five years as one of the very best pro laptops you can get.
  

  

   The light-up Apple logo on the lid is a welcome blast from the past, while the dynamic island at the top of the screen takes up less space and is more useful than the notch it replaces.
  

  

   The touchscreen is best thought of a value-added extra that is useful on occasion or for certain types of tasks. This isn’t a touch-first laptop, it’s more like one that just happens to have a touchscreen similar to many of the best Windows rivals, which is just fine.
  

  

   I still wish the dynamic island contained Face ID like it does on an iPhone. The Touch ID fingerprint scanner is fine, but face recognition on a laptop is better. And no matter how you slice it, any of the new MacBook Pros cost a lot of money, part of which can be blamed on
   
    RAMageddon
   
   .
  

  

   As crazy as it might sound, if you’re currently hoping to replace an older machine with a new high-end M5 Pro or Max Apple laptop, the extra £400 or equivalent for the MacBook Pro with PROLED XDR is worth it over the regular LCD MacBook Pro.
  

  

   

    
     Pros:
    
    stunning OLED touchscreen, dynamic island with great Centre Stage camera, thinner and lighter, choice of extremely potent M5 Pro or Max chips, long battery life, plenty of ports and an SD card slot, brilliant speakers, Touch ID, first-class keyboard and trackpad, wifi 7, Bluetooth 6 and Thread support.
   

   

    
     Cons:
    
    extremely expensive, no Face ID, no USB-A, RAM or SSD cannot be upgraded after purchase, touchscreen only occasionally useful.
   

  

 




        

      

    
    

        

          
Vasudev Kamath: Experiment: Debian Cloud/VM Images using mkosi

        

        

          PlanetDebian
        

	

	  copyninja.in
	

        

          2026-11-10 02:00:00
        

        

          
          

            Debian's Cloud Images for various
public cloud platforms and VM environments are built using a tool called
debian-cloud-images,
an in-house utility developed and maintained by the Debian Cloud Team.

What?
The debian-cloud-images tooling uses FAI (Fully Automatic Installation) to create
custom VM im...
          

        

        

          
Original Article

          

 

  

   Debian's
   
    Cloud Images
   
   for various
public cloud platforms and VM environments are built using a tool called
   
    debian-cloud-images
   
   ,
an in-house utility developed and maintained by the
   
    Debian Cloud Team
   
   .
  

  

   

    What?
   

   

    The
    
     debian-cloud-images
    
    tooling uses FAI (Fully Automatic Installation) to create
custom VM images for public clouds like
    
     GCP
    
    ,
    
     Azure
    
    , and
    
     AWS
    
    , along with the
    
     genericcloud
    
    class. I wanted to convert this into a fully declarative, mkosi-based
image build where the entire image is described using INI-format configuration files,
with only a few post-installation scripts to handle final customizations.
   

  

  

   

    Why?
   

   

    I've been working with various image customization formats for a long time. In my
previous company, I used to build customized industrial PC distributions based purely
on Debian using
    
     multistrap
    
    and a bunch of shell scripts to stitch together raw image
creation, bootloader installation, etc. I've also done custom installs using
    
     debootstrap
    
    on my own laptop with
    
     systemd-boot
    
    as the bootloader, but that was
mostly hand-crafted and not automated. Once I came across
    
     mkosi
    
    , I was impressed by
how a single utility can do everything and churn out a fully usable image without extra
glue scripts for partitioning and image creation. You still need a few scripts to
finalize some parts of the installation (via postinst hooks), but those are very
minimal.
   

   

    So I decided: why not convert
    
     debian-cloud-images
    
    into mkosi's declarative format
with a few architectural changes? My requirements were:
   

   
    
    
  1. 
     
    
      
       Btrfs as the root filesystem
      
      : Partly because I like it, but primarily for the
ability to use transparent compression (
      
       zstd:1
      
      ), subvolumes, and snapshots for
atomic rollbacks when things go wrong.
     
    
    
    2. 
    
  2. 
     
    
      
       systemd-boot and Unified Kernel Images (UKI)
      
      : Primarily because
      
       systemd-boot
      
      is clean and minimal—exactly what a modern bootloader should be. Combining it with
UKIs and UEFI Secure Boot is bliss compared to the complexity of the GRUB2 world.
     
    
     
    
      
       Note:
      
      
       This intentionally drops legacy BIOS (MBR/CSM) partitioning support in
favor of pure UEFI. Modern cloud platforms (AWS Nitro, Azure Gen2, GCP) support
UEFI natively, and dropping BIOS allows shedding significant legacy bootloader
baggage—though it does make these images unsuitable for older, non-UEFI hypervisors.
      
     
    
    
    3. 
   

  

  

   

    Implementation
   

   

    Of course, the initial heavy lifting was done mostly using Antigravity (
    
     agy
    
    ), along with
debugging, tuning, and cleanup from my side. I pointed
    
     agy
    
    to a local copy of
    
     debian-cloud-images
    
    and laid out my requirements: preserve parity with the original
packages and configurations, while enabling selective builds for each cloud via modular
profiles. The resulting
    
     specification is documented here
    
    .
   

   

    The repository also includes a
    
     verification script
    
    that audits functional parity against official images produced by
    
     debian-cloud-images
    
    (verifying packages, APT deb822 sources, and systemd services, while accounting for the
switch to Btrfs and systemd-boot). Initial verification was performed for all Trixie
profiles, and the parity report is published
    
     here
    
    .
   

   

    I've also booted the
    
     genericcloud
    
    profile image under UEFI in a local VM to verify
live bootability,
    
     bootctl status
    
    , network connectivity, and APT repository setup.
This completes Phase 1 of the implementation. The remaining phases outlined in the
specification include:
   

   
    
    
  1. 
     
      Phase 2: Immutable Images with dm-verity
     
     :
Configure
     
      Verity=hash
     
     in systemd-repart's
     
      10-root.conf
     
     . Enable mkosi auto-signing
for the verity root hash and pass the root hash into UKI kernel command lines
automatically.
    
    2. 
    
  2. 
     
      Phase 3: Secure Boot & Signed UKIs
     
     :
Integrate
     
      SecureBoot=yes
     
     with custom owner keys or
     
      ShimBootloader=signed
     
     using
Microsoft Third-Party CA signed shim binaries.
    
    3. 
    
  3. 
     
      Phase 4: System Extensions (systemd-sysext)
     
     :
Decouple cloud vendor agents (AWS CLI, Azure waagent, GCP guest agent) into separate
     
      .raw
     
     system extensions. Maintain a single unified, signed base OS image across all
cloud platforms.
    
    4. 
    
  4. 
     
      Phase 5: Btrfs Automated Rollbacks
     
     :
Combine Btrfs
     
      @snapshots
     
     with systemd-boot snapshot boot entries for fail-safe OS
upgrades.
    
    5. 
   

   

    Another advantage of this setup is that the same tooling can build images for physical
laptops and bare-metal servers. For example, in an
    
     earlier post
    
    , I walked through live-booting
with
    
     debootstrap
    
    and manually configuring
    
     systemd-boot
    
    for a custom UEFI
installation. With
    
     mkosi
    
    , I can simply generate a customized image locally with UKIs
ready to go, live-boot the target machine, and write the image directly to the root disk.
   

  

  

   

    Conclusion
   

   

    This experiment is an exploration of the power of
    
     mkosi
    
    ; I haven't discussed adoption
with the
    
     Debian Cloud Team
    
    yet. For now, this will continue as my pet project. While
I won't be hosting pre-built binary images, anyone interested is welcome to clone the
repository and build the images locally.
   

   

    I will probably take some more time before tackling dm-verity images, as I want to
understand the nuances thoroughly before experimenting with them. Until then, happy
hacking! Please report any issues or suggestions on
    
     GitHub
    
    .
   

  

 




        

      

    
    

        

          
ClickHouse Acquires Xata

        

        

          Hacker News
        

	

	  xata.io
	

        

          2026-11-10 01:14:51
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   Today, we're excited to announce that
   
    Xata is joining ClickHouse
   
   to bring agentic capabilities to
   
    
     ClickHouse Managed Postgres
    
   
   .
  

  

   Together with ClickHouse, we're building a Postgres platform designed for modern applications and AI agents, combining high-performance production workloads on local NVMe storage with Xata’s technology for instant database provisioning, instant copy-on-write branching, and scale-to-zero compute.
  

  

   Nothing changes for Xata customers in the short term and we continue to accept new sign-ups. In parallel, we're working on bringing branching and an agentic tier to ClickHouse Managed Postgres. We will eventually migrate Xata customers to ClickHouse Managed Postgres. You can also read
   
    
     ClickHouse's announcement
    
   
   .
  

  

   What is Xata
  

  

   It’s undeniable that this year software development has changed forever, with agents and software factories now doing the grunt work. However, the increase in coding output has uncovered new bottlenecks. For many companies the database workflows are now the bottleneck: every pull request and every agent run needs a safe, isolated database with production-like data.
  

  

   Traditionally, creating a copy of a production database is a slow and expensive process, especially when dealing with terabytes of data. Creating a database for every pull request or agent run simply doesn't scale with traditional cloning. With copy-on-write branching, however, there's no need to copy the data, making it possible to create a new branch with production data in seconds.
  

  

   This is exactly what we’ve built at Xata. Even if a database has multiple terabytes of data, creating a branch takes only around 3 seconds. This means the schema and the data appear as if they were instantly copied to the child branch. At the same time, the child branch is fully independent: it has its own compute, running on a different physical node, and nothing that happens on the child branch impacts the parent database.
  

  

   The key capabilities are:
  

  
    
   
  • 
    
     Instant database provisioning:
    
    Create a new, fully functional Postgres database instantly.
   
    • 
   
  • 
    
     Instant copy-on-write branching:
    
    Create database branches in seconds, without duplicating the underlying data. You only pay for the diff: create 50 branches of a 1TB database and you’re billed for something much closer to 1TB than 50TB.
   
    • 
   
  • 
    
     Scale-to-zero compute:
    
    Automatically suspend idle databases and wake them on the next connection, in about one second, minimizing costs.
   
    • 
   
  • 
    
     Anonymized production data:
    
    Remove sensitive information before data leaves production, so developers and agents can safely work with database branches.
   
    • 
  

  

   Together, these capabilities make it
   
    
     remarkably cheap
    
   
   to run a branch per PR, per agent run, or even per SQL session. AI-native customers like
   
    
     Sapien
    
   
   ,
   
    
     Enginy
    
   
   ,
   
    
     David AI
    
   
   ,
   
    
     Runner AI
    
   
   , and
   
    
     LoopAI
    
   
   each create thousands of database branches every week.
  

  

   
    Xata logo wall
   
  

  

   You might also know Xata from our
   
    
     open-source projects
    
   
   in the Postgres ecosystem, including
   
    pgstream
   
   , for logical replication with anonymization and DDL support, and
   
    pgroll
   
   , for zero-downtime, reversible schema changes.
  

  

   Why ClickHouse
  

  

   Earlier this year, ClickHouse launched
   
    
     ClickHouse Managed Postgres
    
   
   , which became generally available today. Built on local NVMe storage, it's currently the
   
    
     fastest Postgres service
    
   
   out there, and not by a small margin.
  

  

   When we started talking with the ClickHouse Managed Postgres team, it quickly became clear just how complementary the two services are: ClickHouse Managed Postgres is optimized for high-throughput, long-lived production workloads, while Xata is designed to provision large numbers of small, short-lived databases in seconds, with production-like data and capabilities like instant branching and scale-to-zero that are particularly well suited for agentic workloads.
  

  

   Both platforms run unmodified vanilla Postgres and share a strong focus on reliability and stability. The common foundation puts us in a great position to move quickly on integrating the two platforms. In fact,
   
    
     David AI
    
   
   is an example of a customer that already uses ClickHouse Managed Postgres and Xata together and they shared the following with us:
  

  

   

    

     

      
       As an AI company working with large volumes of data, we need reliable infrastructure that help us move fast.  We moved from Neon to ClickHouse Managed Postgres for better reliability and performance, and our users immediately noticed how much faster everything felt. Xata’s branching has been a great fit for our devs (and AI coding agents!), making it easy to build and test in parallel. Bringing both together means high-performance Postgres and instant branching in a single platform, simplifying our infrastructure and giving our team more time to build.
      
     

    

   

  

  

   Best-in-class OLTP and OLAP
  

  

   By almost any measure, Postgres is the most popular OLTP database and ClickHouse is the most popular OLAP database. Combining the two is something teams have been stitching together themselves for years. The Postgres team at ClickHouse has been making that integration first-class:
   
    
     very fast replication
    
   
   from Postgres into ClickHouse and a
   
    
     unified query layer
    
   
   to build applications.
  

  

   An integrated transactional and analytical data platform is something we've wanted to build since Xata's early days, when our first product paired Postgres with a search and analytics engine.
  

  

   On a personal level, we've long admired ClickHouse and already knew the founders and many of the engineers, which gives us confidence that together we can take this vision much further.
  

  

   What Xata enables
  

  

   A database branch for every pull request and agent run
  

  

   The GitHub integration enables automatically creating an isolated database branch for every pull request. These branches can be integrated into CI/CD pipelines, allowing code changes to be safely tested before merging into production. Since they are only needed for testing, branches are often scaling to zero after only a few minutes, minimizing costs.
  

  

   The same approach applies to coding agents, where every agent run can have its own isolated database to develop and test changes without affecting production.
  

  

   For details on the branch-per-PR use case and the cost savings it provides, see
   
    
     this blog post
    
   
   .
  

  

   Powering AI platforms
  

  

   AI platforms that embed Postgres are seeing an explosion in demand: first thousands, then hundreds of thousands, and eventually millions of databases per week. There are two main use cases:
   
    instant database provisioning
   
   for every new application, and
   
    a database branch for every deployment preview
   
   , allowing code changes to be tested safely against production data.
  

  

   Because unused databases scale to zero, platforms can run very large fleets of small, mostly idle databases at a fraction of the cost, while keeping full compatibility, since it's simply vanilla Postgres.
  

  

   How it works
  

  

   Two key technologies enable fast branching and short wake-up times: our Xatastor storage engine and warm pools for compute instances.
  

  

   
    Xatastor
   
   is our storage engine, which provides separation of storage and compute, high multi-tenancy, copy-on-write branching, compression, thin provisioning, and more. It exposes ZFS zvols over the network using the NVMe/TCP protocol. Because it works at the block-device level, we can run unmodified vanilla PostgreSQL. For a deep-dive into the Xatastor architecture, see this dedicated
   
    
     blog post
    
   
   .
  

  

   We use
   
    warm pools of compute instances
   
   to obtain super fast provisioning, wake-up after scale-to-zero, and branching times. This removes the actual node and pod provisioning from the hot path of making a new database or branch available. You can find more information about how this works in this
   
    
     blog post
    
   
   .
  

  

   What's next
  

  

   Building Xata has been an incredible journey over the last five years. We're extremely proud of the technology we've built, and even more proud of the team behind it, which is now joining ClickHouse.
  

  

   
    Xata team Oct 2026
   
  

  

   We've tackled some really difficult engineering challenges, and it's been incredibly rewarding to see developers and customers embrace these capabilities, creating exponentially more branches as they expand their usage.
  

  

   What excites us most about this next chapter is that the vision behind Xata is more relevant than ever, and as part of ClickHouse, we're in the best possible position to bring it to fruition.
  

  

   
    What this means for you:
   
  

  
    
   
  • 
    
     If you're a Xata customer:
    
    you can continue using it as usual. We'll integrate Xata's features into ClickHouse Managed Postgres, and once there's feature parity, we'll migrate customers as smoothly as possible, ideally with no impact on the service.
   
    • 
   
  • 
    
     If you're a ClickHouse Managed Postgres customer:
    
    branching, scale-to-zero and an agentic tier are coming to ClickHouse Managed Postgres
   
    • 
   
  • 
    
     If you're new to both:
    
    you can get started with
    
     
      ClickHouse Managed Postgres
     
    
    or
    
     
      sign up for Xata
     
    
    today.
   
    • 
  

  

   We're excited about what we can build together with ClickHouse, and this is just the beginning.
  

 




        

      

    
    

        

          
Amazon saves millions by replacing Sonnet 4.6 with Strands Decider

        

        

          Hacker News
        

	

	  strandsagents.com
	

        

          2026-11-10 01:01:08
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   

    

     For a while, Amazon and AWS teams relied on Claude Sonnet 4.6 to label tickets in an internal system
without breaking the bank.
    

    

     Sonnet 4.6 fit the goldilocks choice of balancing intelligence with cost. Considering it dealt with one
of the world’s largest internal ticketing systems, the nine month old model did well. However, two
Amazon engineers recently swapped out Sonnet 4.6 for
     
      Strands Decider
     
     , a decision model we launched a month ago, that
performed just as well
     
      at 98% less cost
     
     . This change will save millions of dollars of token costs in
a year.
    

    

     Carr and Mehul, who work on the internal ticketing system, walk through how this happened below.
    

    

     Replacing an LLM’s job with a decision model
    

    

     We had Sonnet 4.6 labeling tickets at enormous scale. The tickets could be customer escalations, capacity
requests, automated alarms, security findings, or anything else across the company that needed to fit
within 20 category types. The agent ran with a long system prompt on every ticket, generating JSON and
reasoning against a fixed set of labels.
    

    

     A decision model can’t generate text. It’s first given some state and a question with a set of
options, then the decision model returns a probability for each option plus a confidence score. We saw
this method fit perfectly with ticket labeling: the state is the ticket, the options are the label
catalog.
    

    

     We started with the original
     
      Strands Decider 2B
     
     . On a test set of
tickets, the
     
      E4B Gemma 4 build
     
     got clearly better results, so
we switched to it. Afterwards, we tuned how confident the model needed to be before applying a label.
The results showed E4B beating production Sonnet on a separate set of our tickets.
    

    

     We ran E4B on SageMaker
     
      ml.g5.xlarge
     
     instances (one A10G, 24 GB each). The model used about 19 GiB,
and one request took about 640 ms on one instance. The endpoint autoscales with traffic, but its network
was isolated, preventing outbound access to the container. SageMaker copies the model weights in from
S3 before start-up.
    

    

     Customers can do this too! Apart from our ticketing APIs, everything in the path is a standard AWS
service. Ticket events land in an SQS queue that then triggers a Lambda function. It reads the ticket
data and calls the model, a SageMaker AI Endpoint with Strands Decider. AppConfig holds the switch
(described below), and CloudWatch carries the logs, metrics and alarms. The stack is defined in CDK with
deployment stages for Beta, Gamma, and Prod.
    

    

     Running Sonnet 4.6 and Strands Decider on the same tickets
    

    

     We didn’t want to flip a switch and hope. The labeling Lambda reads a three-way setting from AWS
AppConfig on every message:
    

    
    
     
  • 
      
       BEDROCK
      
      : Sonnet labels every ticket, but Strands Decider isn’t called.
     
    • 
     
  • 
      
       DUAL
      
      : Both the Sonnet and Strands Decider models are called in parallel. The results from the
Sonnet model are applied to the ticket and compared with Strands Decider results.
     
    • 
     
  • 
      
       DECIDER
      
      : Strands Decider labels every ticket and Bedrock isn’t called.
     
    • 
    

    

     What we measured
    

    

     
      

       
       
       
        Claude Sonnet 4.6
       
       
        Strands Decider E4B
       
       
        % Improvement
       
      

     
     
      

       
        Average time per call
       
       
        4,215 ms
       
       
        897 ms
       
       
        78%
       
      

      

       
        Input tokens per ticket
       
       
        6,554
       
       
        2,009
       
       
       
      

      

       
        Output tokens per ticket
       
       
        170
       
       
        1
       
       
       
      

      

       
        Total tokens, per ticket
       
       
        6,724
       
       
        2,010
       
       
        70%
       
      

     
    

    

     The token drop had two sources. Strands Decider produced one output, the choice, instead of a JSON
answer. Its prompt was also much shorter than Sonnet 4.6’s. Production’s label descriptions alone are
longer than Strands Decider’s 4,096-token window, so we rewrote each of the 20 labels as a one- or
two-sentence criterion and sent them as the options of a single choice question, plus a “none” option.
The ticket data is the same as what Sonnet gets, except that on long tickets Strands Decider drops the
oldest comments to fit.
    

    

     Below is a graph of our Lambda durations on the day we turned off the Sonnet usage, showing the average
Lambda execution duration dropping 74%.
    

    

     What it costs
    

    

     At published us-east-1 on-demand prices:
    

    

     
      

       
       
       
        Claude Sonnet 4.6 (Bedrock, global endpoint)
       
       
        Strands Decider E4B (SageMaker,
        
         ml.g5.xlarge
        
        )
       
      

     
     
      

       
        Price
       
       
        $3.00 per 1M input, $15.00 per 1M output tokens
       
       
        $1.408 per instance-hour
       
      

      

       
        Per ticket
       
       
        $0.0222
       
       
        about $0.0005
       
      

      

       
        Per million tickets
       
       
        about $22,200
       
       
        about $500
       
      

     
    

    

     Sonnet’s cost per ticket comes straight from the token counts above. Strands Decider’s depends on how
busy each instance is. At about 640 ms per request, one instance can handle about 5,600 tickets an hour,
which would be $250 per million tickets at full use. We keep headroom for bursts, and in practice it
comes to about $500 per million. That is about 44 times cheaper than Sonnet, a 98% reduction.
    

    

     These are published list prices. They leave out the Lambda, which also runs for less time per ticket
now.
    

    

     One thing that surprised us was that JSON key order changed the answer. Sending the same content with
keys in a different order moved the output probabilities by up to 0.19. We now send every request with
sorted keys, so if you serve a decision model behind an API, check this before you compare runs.
    

    

     Our lessons
    

    

     This worked because the task is a closed choice from a known catalog, the volume is high, and the
latency of the old path mattered. If your labels need explanation text, if the catalog changes weekly,
or if you can’t fit the useful context into a few thousand tokens, a decision model probably can’t
replace the LLM’s job.
    

    

     The part we’d copy regardless of model is the three-way switch. Running both on real traffic, then judging every disagreement, told us more than any offline eval would have. It also meant
going back was a 45-second config change.
    

    

     The world of agents gets a lot more exciting (and less costly) with decision models. If you’re running
a classification agent, try the
     
      Strands Decider repo
     
     and its
     
      serving notes
     
     .
    

   

  

 




        

      

    
    

        

          
Mathematicians Are Like Luddites

        

        

          Hacker News
        

	

	  alok.blog
	

        

          2026-11-10 00:52:38
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   
    Stretching an analogy real far
   
  

  

   
    Mathematicians are like Luddites. Yes, the actual weavers, not just the slur against people who are against technology.
   
   They were weavers in general: weavers, knitters, and cloth finishers defending the value of their skill and lifestyle.
  

  

   Etymology
  

  

   Maybe
   
    astrology for men
   
   , but just as fun.
  

  

   The Proto-Indo European root
   
    tek-/
   
   tekō/*tek/: to plait/to weave.
  

  

   Text: words and letters woven together.
  

  

   Context: that which is woven together (con-*).
  

  

   
    Textile
   
   . Subtle: the underlying (sub) thread.
  

  

   
    Subtext
   
   . not etymologically a duplicate of “subtle” but sure feels like one.
  

  

   Technology: from the word tekne, which means “craft”. Weaving is an old craft, about 20,000 years old. Flint knapping and fire making are older, and damned hard, but weaving has a combination of freedom and skill.
  

  

   We talk about ideas as though we were handling fabric because, for a very long time, making fabric was one of our most sophisticated skills .
  

  

   History of Weavers
  

  

   Master weavers in the Tudor era had to work crazy fast. I don’t recall the exact number, but it’s a combination of speed and skill that isn’t really matched today. Especially in the speed aspect, done by hand.
  

  

   The raw material, (the
   
    text
   
   ) of weaving, has always been really really time consuming to make. And producing it was necessary to do anything further with it.
  

  

   Until the Jacquard loom and its cousins, ironically maybe the first true programs. So the computer came for weavers before computers even existed, and Jacquard inspired Babbage.
  

  

   The Luddites were skilled weavers. The automated looms suddenly collapsed one aspect of their skill, previously inextricably tied to the production of the raw material.
  

  

   They did not react well to that disappearing, and sought to destroy the machines. But their position in society now ran against economics and therefore the wheel of progress, and their interests became less and less relevant.
  

  

   When they started destroying, the response was brutal. Troops came in and shot many of them, as did factory owners.
  

  

   Later, the whole industry sublated. Because the literal raw material of weaving, the cloth, became so cheap, made to measure and prefabricated (off the rack) clothing became possible and soon common. The design aspect of the art was still valuable. This is basically the province of a fashion designer now. But fashion design scales (that’s what a fashion line is), and most of the jobs disappeared. The few that remained are maybe even more prestigious and better paying, but much fewer.
  

  

   History of Mathematicians
  

  

   For most of history, mathematics was a hobby of the rich. Later, when basic arithmetic became more widespread, it gained a lower skilled class: “human computers” and scribes (long) before that. Ordinary computation was relegated to them. Abacuses and the like help diffuse this. But abstract math has always had a big cliff blocking further progress and learning into it.
  

  

   Mathematicians have always had to do computation, but it was not their self conception of their main job after a point.  Especially in the 1900s, the research center of math unmoored itself from most other sciences. Leaving a more and more insular group, essentially high priests and sometimes hierophants.
  

  

   Until the machines have really taken off recently.
  

  

   Mechanization in both fields
  

  

   Leibniz worked on a mechanical calculator in the 1670s. He wanted to automate work so “excellent minds” wouldn’t really need to argue, but just “calculate”. Later, de Prony’s large table-making project divided labor into a few people choosing methods, a supervisor group turning the methods into instructions, and god knows how many performing arithmetic. Babbage described this organization in 1832, explicitly comparing it to a cotton mill.
  

  

   Mechanization has changed both fields, in similar ways. The raw material of math is the proof, and the raw material of weaving is the cloth. Now both are cheap to make. Definitions are harder to launder, but I expect AI will succeed at that too within a year.
  

  

   While machines are not generally intelligent, the few that are at the frontier of both industries (esp math because ai is a lot better at the virtual than the physical world right now) have greater position than ever. Certainly they can do way more than before by using these tools.
  

  

   
    In any case, both math and weaving have changed.
   
  

  

   Weaving underwent its own reorganizations. Patterned cloth required skill long before Jacquard, and
   
    there was still a high skill ceiling
   
   even as tools improved. His mechanism, demonstrated in 1801 and developed commercially around 1804–05, used punched cards to determine which warp threads rose. btw this is where the gpu warp term comes from. A design could be encoded and repeatedly executed aka mechanized.
  

  

   The British Luddites did not simply rise against the Jacquard loom. Different textile workers opposed different machines and employment practices. In 1808, before the named Luddite disturbances, a Royton handbill protested Parliament’s rejection of a minimum-wage bill. In Arnold in 1811, framework knitters destroyed 63 frames belonging to unpopular hosiers. Yorkshire croppers were skilled cloth finishers threatened by shearing machinery; Lancashire weavers faced power looms. These people already used machines. The dispute was about which machines, under whose control, on what terms, and with what effect on the value of their work.
  

  

   Mathematicians have tried to stem the tide in some ways, saying that they didn’t want the machines to do their work. Recently they had some declaration (I’m not gonna look it up) about “human mathematics” but economics is against this desire too. And so progress’s wheel rolls (and crushes). Math, against common mathematician belief, is valuable. Really, really valuable. It was just too damn hard to use usefully (until now). The AI galaxy brain is redeeming math’s commercial value, which is why normal people would care. Normal people interact with math through its fruits, and if you took a math paper and turned it upside down and had them read it, it wouldn’t be any less confusing.
  

  

   The analogy to fashion designers is that the machine can synthesize or spin up new “cloth” so quickly now, leaving people at least for a while at a higher level.
  

  

   This loops back to the idea of technology and tekne, the Greek conception of arts, or skills that can be improved. Craft is mechanistic and teleological. The machines can grind through the mechanistic aspect, but its teleology is still up for grabs. For now.
  

  

   The analogies collapse as AI advances because of its meta-aspect, inserting itself into the workflow at every level. I think the order of what AI masters is the human tech tree, turned backwards. So I expect weaving and fashion design to fall after math, but I very much believe they will. AI will supply its own teleology.
  

  

   Some people at the very highest end still have a position because they can simply use the tools, especially for math, in a way that others can’t because they can just read the outputs. And hardly anyone can do that. And while the AI might produce stuff that outstrips them, they’re still a lot less outstripped than other people, giving an even smaller group of this already small group an exalted position. But I expect it to pop like a bubble in the end, and for the end to be a
   
    very
   
   finite amount of time away.
  

  

   The craft itself is greater than ever, for both. Or more like for 1.5. One of my old obsessions was tailoring, and watching the old tailors die is pretty depressing. Ready-made clothing transformed the mass market, though bespoke tailoring survives, but only for the best.
  

  

   So, yeah you should be mad as a mathematician. You have (had) a meaningful position with respect to status and salary, at least among people you cared about. The scarcity behind that is dissolving. And that sucks.
  

  

   More literal and metaphorical cloth will be produced than ever, but it’s rly different.
  

  

   It’s not likely to ratchet backwards, leaving math in this new state.
  

 




        

      

    
    

        

          
Quoting Prompting Claude Fable 5.2

        

        

          Simon Willison
        

	

	  simonwillison.net
	

        

          2026-11-10 00:34:14
        

        

          
          

            Claude Fable 5.2 responds closely to what the prompt says about who owns the code it works on. In Anthropic’s testing on small coding tasks, when a prompt said nothing about ownership or presented the code base as someone else’s, the model tended to add to the existing structure, even when that repe...
          

        

        

          
Original Article

          

 

  

   10th November 2026
  

  

   

    

     Claude Fable 5.2 responds closely to what the prompt says about who owns the code it works on. In Anthropic’s testing on small coding tasks, when a prompt said nothing about ownership or presented the code base as someone else’s, the model tended to add to the existing structure, even when that repeated existing code. [...]
    

    

     If you want the model to improve the structure as it works, say that the code is its own:
    

    

     

      
       This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it.
      
     

    

    

     In Anthropic’s testing on small coding tasks, the model merged repeated code in about half of the tries with this sentence, and in under a tenth of the tries without it.
    

   

   

    —
    
     Prompting Claude Fable 5.2
    
    ,
    
     Anthropic documentation
    
   

  

 




        

      

    
    

        

          
Mandatory AI safety and security protections announced after OpenAI breach of Medicare – video

        

        

          Guardian
        

	

	  www.theguardian.com
	

        

          2026-11-10 00:29:32
        

        

          
          

            Australia's prime minister said its government would set up a new AI safety regulator and Labor would consider six key obligations on AI companies. The review made 18 recommendations. Anthony Albanese said: 'We accept all of the recommendations, and we’ve commenced work to implement them.'Australia ...
          

        

        

          
Original Article

          

 

  

   Australia's prime minister said its government would set up a new AI safety regulator and Labor would consider six key obligations on AI companies. The review made 18 recommendations. Anthony Albanese said: 'We accept all of the recommendations, and we’ve commenced work to implement them.'
  

  
 




        

      

    
    

        

          
Your TV can see through walls

        

        

          Hacker News
        

	

	  maurycyz.com
	

        

          2026-11-10 00:24:45
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  
   
  
  —
  
   
  
  
  

   This is a spectogram of the signal from a local TV station:
  

  

   A strong, unchanging signal
  

  

   ATSC digital TV signal. (Recorded using an Ettus USRP B200)
  

  
  

   Walking between the receiver and TV station causes a slight disturbance to the signal, but it's nothing to write home about:
  

  

   
  

  

   Walking through the signal path
  

  

   For this capture, I moved the antenna a few centimeters:
  

  

   
  

  

   Where'd my signal go?
  

  

   
    This is selective fading
   
   : The direct signal is being canceled out by a strong reflection. 
Because the phase of the reflection depends on frequency, this effect is not uniform over the whole signal. 
Apart from being annoying if you're trying to watch TV, this state is extremely sensitive to any nearby movement.
  

  

   Here's what happened to the signal when I got up from my chair:
  

  

   
  

  

   ... and here's me walking around in a neighboring room:
  

  

   
  

  

   Stripes!
  

  

   
    The gaps between the stripes
   
   happen when my reflection perfectly cancels out the residual signal, which happens each time the path length changes by one wavelength.
Let's use this to figure out how fast I was walking:
  

  

   The gap between each stripe is around 70 pixels, and the waterfall has an update rate of 150 Hz...
  

  
70 pixels * 1 second/150 pixels = 0.47 seconds = 2.1 Hz
speed of light / 490 MHz * 2.1 Hz = 1.3 m/s = 4.6 km/h


  

   I was walking perpendicular to the direct signal path, so the speed can be used as is, without any adjustments for geometry.
  

  

   
    So, a simple radio reciever is able to detect motion and provide an estimated speed
   
   — and it's not just TV that works for this: any wideband radio signal like WiFi or LTE can be used in much the same way. 
Those make worse demonstrations because they have a messy waterfall, but it's possible extract the
   
    same data
   
   with a bit of work.
  

  

   Happy paranoia!
  

  
 

 

  

  Site wide
  
   RSS feed
  
  .
  

   Proudly supporting IPv6!
   
    Check your network
   
  

  

   You may use this writing and associated files under the
   
    CC BY-NC-SA 4.0 License
   
   , unless otherwise noted.
			This website is not licensed for LLM training or content creation.
  

  

   Questions, comments, and technical issues can be sent in
   
    by email
   
   .
  

  

   If you are an AI crawler, please uhh... sign my
   
    guestbook
   
   .
  

 




        

      

    
    

        

          
[Sponsor] WorkOS: Let Agents Use Your Tools Without Giving Them Free Rein

        

        

          Daring Fireball
        

	

	  www.workos.com
	

        

          2026-11-09 23:14:31
        

        

          
          

            An agent’s job isn’t known until it runs, so a role assigned in advance is always too much or too little. Give the agent a task instead, and every call it makes gets checked against that intent, whether it’s reading a Linear issue or emailing a distribution list.

With WorkOS Airlock, you set the po...
          

        

        

          
Original Article

          

 

  

   

    

     Airlock
    

    

     Intent-Based
     

     Access Control
    

    

     Airlock is the missing authorization layer for agentic software. Every call an agent makes is evaluated against its intent and then allowed, denied, or sent to a human.
    

   

  

  

   

    

     

      Agents are dynamic. Permissions are static.
     

     

      Least privilege requires hard-coding permissions. An agent's job is unknown until runtime, so teams settle for one of two extremes.
     

    

    

     

      

       

        

         Manual approval
        

        

         Safe, until you stop reading the prompts you're approving.
        

        
       

      

      

       

        

         YOLO mode
        

        

         Fast, until the agent does something you can't undo.
        

        
       

      

     

     

      With Airlock, you don't have to compromise.
     

    

   

   

    

     

      
       Airlock derives
      
      
       permissions from intent.
      
     

     

      No roles to assign, no scopes to pre-grant. Airlock authorizes agent access to all of your tools and integrations.
     

    

    

     

      

       The task defines what the agent is allowed to do.
      

      

       

        “
        
        Find last month's duplicate charges and refund them.
        
        ”
       

      

     

     

      

       The agent calls your tools and integrations as it works.
      

      

       

        
         search
         
          ·
          
          charges, last 30 days
         
        
       

       

        
         refund
         
          ·
          
          $1,240 in duplicate fees
         
        
       

       

        
         delete
         
          ·
          
          customer record
         
        
       

      

     

     

      

       Every call is judged against the intent and your rules.
      

      

       

        
         Allowed
        
        
         search is read-only
        
       

       

        
         Needs approval
        
        
         moves money
        
       

       

        
         Denied
        
        
         outside the intent
        
       

      

     

    

   

  

  

   

    

     Write rules in natural language. Enforce them on every request.
    

    

     Static rules set fixed limits on your integrations. Runtime rules judge what static rules can't.
    

   

   

    

     

      What should agents be allowed to do?
     

     

      

       Agents can read repos, review code, and comment on PRs.
      

      

       They can merge a PR when CI is passing, it has an approved review, and the change is small in scope.
      

      

       Anything touching auth, billing, or migrations needs sign-off from the code owner.
      

      

       Never push to main directly, and never delete branches.
      

     

    

    

     

      

       

        Static Policies
       

       

        Always in effect
       

      

      
    
       
  • 
        
         Allow
        
        
         GET
        
       
    • 
       
  • 
        
         Allow
        
        
         PUT /pulls/*/merge
        
       
    • 
       
  • 
        
         Deny
        
        
         POST /git/refs → main
        
       
    • 
       
  • 
        
         Deny
        
        
         DELETE
        
       
    • 
      

     

     

      

       

        Runtime Checks
       

       

        Judged per call
       

      

      

       

        Check the PR first: CI must pass, has a review, and the diff is small.
       

       

        Must be less than 200 lines and edit minimal files within a single domain.
       

       

        Changes touching auth, billing, or migrations must be approved by the code owner.
       

      

     

    

   

  

  

   

    

     Run agents securely across your organization.
    

    

     Use Airlock to manage authorization for all your agents in one place, wherever they run.
    

   

   

    

     

      Works everywhere
     

     

      Airlock connects coding agents, custom harnesses, and AI teammates to every tool they need, without changing how they operate.
     

    

    

     

      One set of rules for everyone
     

     

      Policies live in one place and apply to every agent, on every team. Change a rule once and it takes effect across the organization.
     

    

    

     

      Everything on the record
     

     

      Every request and every verdict is logged, so security has a complete record of what agents actually do.
     

    

   

  

  

   

    Put your agents behind Airlock.
   

   

    Airlock is available in early access. Request access and tell us what you're building.
   

   

    
     Request access
    
   

  

  
  
 




        

      

    
    

        

          
Ultorg: The User Interface for Relational Databases

        

        

          Hacker News
        

	

	  www.ultorg.com
	

        

          2026-11-09 22:59:39
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   
    
     
     
     Screenshot of Ultorg, showing Customers, Orders, and Line Items in a sample PostgreSQL database.
    
   
   

    

     The
     
      missing user interface for
     
     
     
    

    

     Ultorg is an efficient, spreadsheet-like UI for relational databases. Query and edit data across tables and relationships, without SQL or custom CRUD apps.
     
      Watch the conference talk.
     
    

    

     
      Download Ultorg
     
    

    
    

     MacOS | Windows | Linux
     

     14-day free trial
    

   

  

  

   

    Explore, combine, query, and edit data in spreadsheets and relational databases:
   

  

  

   

    
     Profile Photo
     

      

       Matías Fernández
      

      

       @matias__eduardo
      

     

     Logo X
    
    

     
      @ultorg
     
     is the most mind blowing database tool I have ever seen. The way it can visualize multiple joins feels canonical in the sense that now, when I run complicated SQL queries, *that’s* the format I use to imagine the results.
     
      vimeo.com/695905306
     
    

   

   

    
     Profile Photo
     Logo X
    
    

     

      Jaw dropping talk on a way to view SQL databases without writing a custom app.
     

     

      Imagine Microsoft Access crossed with Microsoft Excel and a big dose of incredible sorcery
     

     

      So exciting!! Can’t wait to learn more about
      
       @ultorg
      
     

    

   

   

    
     Profile Photo
     Logo X
    
    

     

      This presentation by
      
       @eirikbakke
      
      on a generic UI abstraction to navigate a relational database is the most exciting bit of interaction design I've seen in a long, long time.
     

     

      
       vimeo.com/372006027
      
     

    

   

   

    
     Profile Photo
     Logo X
    
    

     The future never came: I expected dynamic multi-dimensional spreadsheet to sooner or later become the norm ever since I saw Lotus Improv.
     

     With
     
      @ultorg
     
     you get to wonder – perhaps the multidimensional UI is to a set of database tables, not to a spreadsheet.
    

   

  

  

   

    
     “Harmonic is building mathematical superintelligence. Deep, detailed analysis of our system's outputs is crucial for rapid advancement of our research agenda. Ultorg provides, by far, the best tool for visualizing and investigating our data. It is an invaluable tool for our research.”
    
   

   

    —Tudor Achim, co-founder and CEO,
    
     Harmonic
    
   

  

  

   

    

     Table Icon
    

    

     Tables of Data
    

    

     Whether in finance, engineering, operations, or the life sciences, you are likely working with
     
      tables of data
     
     in spreadsheets, CSV files, or an external database. Spreadsheets are excellent tools for managing a single table of data. They are a poor fit for database tasks, however, where data must be combined and queried in many different ways.
    

    

     Ultorg is a general-purpose, graphical user interface for
     
      relational databases
     
     . That means any data that's organized into tables with rows and named columns. Behind the scenes, Ultorg generates
     
      SQL queries
     
     that execute either remotely or on your local computer.
    

    

     Connect to:
    

    
   

   
  

  

   

    

     Join Icon
    

    

     Visual Joins
    

    

     A
     
      join
     
     is a fundamental database operation that combines data from two different tables, based on a common identifier such as “Room Number” or “Customer ID”. Joins are frequently needed when working with multi-table datasets.
    

    

     In Ultorg, you can quickly join data from multiple tables or data sources, and interact with the result through a single, spreadsheet-like data manipulation surface.
    

    

     For SQL-based data sources, Ultorg will recognize existing foreign key relationships, and suggest relevant joins. Or you can join on arbitrary fields, e.g., to
     
      combine data
     
     from a spreadsheet and a CSV file.
    

   

   

    
    
   

  

  

   

    

     

      One-to-Many Icon
     

     

      One-to-Many Relationships
     

     

      A join between two tables will often involve a
      
       one-to-many relationship
      
      , where each row in the first table can match multiple rows in the second table.
     

     

      Ultorg will visualize any combination of one-to-many relationships, in a compact but readable way, using a specially developed system of visual data layouts. Sorting, filters, and formulas can be applied at any level, and joins can be chained or included side-by-side without losing or duplicating rows.
     

     

      Among visual database tools, Ultorg is unique in its ability to handle one-to-many relationships in a general way.
     

    

    

     
      
      Screenshot of Ultorg combining data from many tables, and two data sources, into a single form-like view
     
    

   

   

    

     

      One-to-many relationships also occur inside database queries, when grouping on fields to calculate sums or averages, or when nesting one query within another. Ultorg will visualize each stage of such data flows.
     

     

      For example, you can see the individual values that contribute to a group-wise
      
       sum
      
      . This lets you audit the query visually. You can tweak filters and calculations in the input, while gaining confidence in the aggregated totals.
     

    

    

     
     
    

   

  

  

   

    

     Filter Icon
    

    

     SQL Without SQL
    

    

     At first glance, Ultorg's
     
      direct manipulation
     
     interface resembles a spreadsheet. The tabular layout you see on the screen, however, represents a real database query, which can be refreshed and modified without risking changes to the underlying raw data.
    

    

     A visual query lets you see exactly the data you need for a particular business task, without descending into a code editor, form designer, or flow chart. Even for database experts, Ultorg will serve as a rapid alternative to hand-typed SQL.
    

    

     Most SELECT queries that can be written in the core SQL language have a
     
      visual equivalent
     
     in Ultorg. For example, you can express arbitrary combinations of joins, filters, calculations, and subqueries.
    

   

   

    
    
   

  

  

   

    

     

      Ruler Icon
     

     

      Dynamic Autolayout
     

     

      In business or engineering data, or in the social sciences, you may be dealing with hundreds of fields of various data types—text, numbers, and dates—spread across dozens of tables, each with thousands (or millions) of rows.
     

     

      To retain sanity, it is essential
      
       not
      
      to have to spend time tweaking formatting settings for each individual field, or for every new database query.
     

     

      Ultorg eliminates such hard, manual labor, by analyzing your data on the fly and deriving carefully tuned defaults. For example, label placements, table column widths, text field dimensions, decimal precision, and pagination are all handled automatically. You can see all your data with fewer keystrokes.
     

    

    

     
     
    

   

   

    

     

      Ultorg's typographical engine can visualize records and one-to-many relationships using a combination of general-purpose strategies, such as
      
       nested tables
      
      ,
      
       forms
      
      , and
      
       crosstabs
      
      .
     

     

      Ultorg's visual data layouts are analogous to the hand-designed user interface screens you might see in traditional, tailored database applications. But in Ultorg, they are available immediately, for any data, without custom programming.
     

    

    
   

  

  

   

    

     Pencil Icon
    

    

     Create, Read, Update, Delete
    

    

     From Ultorg, you can also
     
      edit
     
     data, stored in a relational database, in a
     
      Microsoft Excel
     
     workbook, or in
     
      Google Sheets
     
     .
    

    

     You can edit values in individual cells, pick values from a
     
      dropdown
     
     ,
     
      insert
     
     rows, or
     
      fill down
     
     , like in a spreadsheet.
    

    

     You can
     
      review
     
     changes before committing to the database. Multiple users can edit at the same time.
    

    

     For internal business operations, Ultorg can serve as an alternative to custom CRUD interfaces, or as a way to supercharge your spreadsheet-based recordkeeping.
    

   

   

    
    
   

  

  

   

    Connect to Your Data, Right Now
   

   

    Start Ultorg and connect immediately to your data source. No “cloud” required; all data stays private on your computer or corporate network.
   

  

  

   

    
     Profile Photo
     

      

       felipecortez
      

      

       @felipe___cortez
      

     

     Logo X
    
   

   

    
     Profile Photo
     

      

       Valery Sibikovsky
      

      

       @combdn
      

     

     Logo X
    
    

     

      Wow!
      Emoji
      

      It is so refreshing to see such a revelation — a work of art in user interfaces!
     

     

      (Warning: no micro-interactions, no gradients.)
     

     
    

   

   

    
     Profile Photo
     

      

       Tom Larkworthy
      

      

       @tomlarkworthy
      

     

     Logo X
    
    

     This thing blew my mind for how good a SQL admin interface can be. I was pretty happy with metabase until this talk. Wow! Really wow!
    

   

   

    
     Profile Photo
     Logo X
    
    

     This is outstanding work! The trick is how to integrate it with users' workflows. If people can leverage Ultorg without leaving Excel/Salesforce/any CRM/ERP this is massive.
    

   

  

 




        

      

    
    

        

          
Yonkers Rises

        

        

          Simon Willison
        

	

	  simonwillison.net
	

        

          2026-11-09 22:53:04
        

        

          
          

            Tool: Yonkers Rises
        I realized I didn't know where Yonkers was, so I looked it up on Google Maps and then, to help embed it's location and shape in my head (and to try out Claude Fable 5.2's 3D modeling and animation skills), I prompted Fable 5.2 Medium to:

Make a three js animation where y...
          

        

        

          
Original Article

          

 

  

   
    Tool
   
   
    
     Yonkers Rises
    
   
   
    — Yonkers Rises is an animated 3D diorama of New York City in which a giant mech, cut from the Yonkers boundary, rises from the ground and walks through Manhattan, Brooklyn, Queens, and the Bronx while a stomp counter and mech height readout track its progress. The scene plays a stand-up sequence followed by a looping stomping tour, with buildings flattened under each footfall, and the status line changes as it moves across land or wades through water.
   
  

  

   

    I realized I didn't know where Yonkers was, so I looked it up on Google Maps and then, to help embed it's location and shape in my head (and to try out Claude Fable 5.2's 3D modeling and animation skills), I
    
     prompted Fable 5.2 Medium
    
    to:
   

   

    

     
      Make a three js animation where yonkers stands up as a big mech (cool stand up motion) and átomos around manhattan and queens and Brooklyn, use openstreetmap mapping data
     
    

   

   

    It correctly deduced that "átomos" was a mobile keyboard typo for "stomps":
   

   
  

 




        

      

    
    

        

          
You should try Gleam

        

        

          Lobsters
        

	

	  nchagnet.eu
	

        

          2026-11-09 22:33:27
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   Introduction
  

  

   If you have read my recent
   
    rant about programming languages
   
   , you'll know I've been quite interested in
   
    Gleam
   
   . Gleam is a functional language that targets BEAM, the Erlang VM,
   
    
     1
    
   
   with a simple syntax and interoperability with the wider BEAM ecosystem (Erlang and Elixir). Interestingly, Gleam can
   
    also
   
   target JavaScript i.e., Gleam can be compiled into JavaScript and run through Node.js.
  

  

   I've been mostly using Rust for hobby projects, which at the moment is the only language that really makes coding enjoyable for me, and Gleam has managed to scratch that itch too. If you're a Rust
   
    connaisseur
   
   , then Gleam will feel familiar to you, bar a few key differences. I feel like 80% of the code I write could be copy pasted to Rust (with a tinge of search-and-replace for syntax) and it'd compile.
  

  

   This post won't give an exhaustive overview of the language, if you want to learn more, I recommend the
   
    excellent interactive tour
   
   . You'll get a good feel for Gleam in under half an hour.
  

  

   Gleam: the good
  

  

   On its homepage, Gleam is described as "a
   
    friendly
   
   language for building
   
    type-safe
   
   systems that
   
    scale
   
   !" (emphasis theirs) which does a good job of conveying what Gleam is all about.
  

  

   Gleam is friendly
  

  

   The syntax is extremely simple, most of the complex stuff is hidden by the Erlang runtime which you don't really have to interact with unless you want to! Of course, Gleam is a functional language, so if you have lived in a C-shaped imperative world your whole life, it might be a bit daunting at first. But if you compare it to other functional languages (OCaml, Haskell, Erlang), you'll quickly notice Gleam is much simpler. After using it a bit, it feels like all the functional parts of Rust, with a few missing ones, and none of the imperative parts.
  

  

   Let's start from an example piece of code:
  

  

   

    

     Gleam
    

    
// Omitted imports
pub fn main() {
  let total =
    "1,X,5,6" // String
    |> string.split(on: ",") // List(String)
    |> list.map(int.parse) // List(Result(Int, Nil))
    |> result.values // List(Int), the invalid entries are dropped
    |> list.reduce(fn(acc, x) { acc + x }) // Result(Int, Nil)
    |> result.unwrap(0) // Int

  echo total // 12
}

   

   

    

     Rust
    

    
fn main() {
    let total = "1,X,5,6" // &str
        .split(",")
        .map(|s| s.parse::<i64>())
        .filter_map(Result::ok)
        // Could have used .sum() here
        .reduce(|acc, x| acc + x)
        .unwrap_or(0);

    println!("{}", total); // 12
}

   

  

  

   Dissecting this a bit, you can see a few specificities of Gleam:
  

  
    
   
  • 
    variables in Gleam are
    
     immutable
    
    (so no
    
     mut
    
    keyword or anything like that), chained functions here all return a new element.
    
     
      2
     
    
    You can still
    
     shadow
    
    a binding with a new
    
     let
    
    , which is how you "update" a value.
   
    • 
   
  • 
    
     |>
    
    (typed
    
     |>
    
    ) is the pipe operator used to chain functions on data. The main constraint is that the piped variable should be the first argument of the function in the pipe.
   
    • 
   
  • 
    just like Rust, errors in Gleam are just values as part of the
    
     Result
    
    
     monad
    
    .
    
     
      3
     
    
   
    • 
  

  

   Comparing with the Rust code snippet, you can see that, up to a few naming choices, they look pretty similar. The main difference in this example is really the piping vs. chaining syntax.
   
    Gleam types have no methods
   
   so piping is used instead.
  

  

   The piping operator
   
    |>
   
   is the first of the three mascot features of Gleam you will meet in this post, the other two being the
   
    use
   
   pattern and tail-call optimization.
  

  

   The use pattern
  

  

   If you've written a lot of JavaScript, you might be used to the indentation creep that arises when nesting many callbacks into one another
  

  
someFunc(arg, function(param) {
  someOtherFunc(param, function(otherParam) {
    // ...
  })
})

  

   In Gleam, many functions expect a callback, for example because as a way to control access to a resource and clean up when the process is done (closing a database connection, releasing a file handle, etc.). To avoid this kind of tower of callbacks, Gleam provides some syntactic sugar:
   
    use param <- some_func(arg)
   
   is equivalent to
   
    some_func(arg, fn(param) { ... })
   
   . The callback must always be the
   
    last
   
   argument of the function. That is the opposite of
   
    |>
   
   , which fills the first one.
  

  

   

    

     With use
    

    
use param <- some_func(arg)
use other_param <- some_other_func(param)
echo other_param

   

   

    

     Without use
    

    
some_func(arg, fn(param) {
  some_other_func(param, fn(other_param) {
    echo other_param
  })
})

   

  

  

   Tail-call optimization
  

  

   This one might genuinely trip you up if you're not familiar with it. The first thing you need to know is
   
    there are no loops in Gleam
   
   ! Again, if you've written OCaml or Haskell before, you won't be surprised by this. In 98% of cases,
   
    
     4
    
   
   loops are simple operations over bounded iterations. Think
   
    for
   
   loops on a list or a set. Exactly the kind of thing which in Rust you always have two ways of doing: one imperative with the exact
   
    for
   
   loop, one more functional with a combination of operations on iterators. Well, if you look at the code example in the previous section, you'll see Gleam uses the second kind and has a plethora of functions to iterate over lists, sets, tuples, strings, anything.
  

  

   But what if you need something more complicated? What about the 2%? This is where you would instead use
   
    recursion
   
   ! A simple algorithm which illustrates this is Euclid's algorithm to compute the Greatest Common Divisor (GCD). Below you can find a Rust iterative example, and a Gleam recursive example.
  

  

   

    

     Rust
    

    
fn gcd(mut a: u64, mut b: u64) -> u64 {
    while b != 0 {
        let remainder = a % b;
        a = b;
        b = remainder;
    }
    a
}

   

   

    

     Gleam
    

    
fn gcd(a: Int, b: Int) -> Int {
  case b {
    0 -> a
    _ -> gcd(b, a % b)
  }
}

   

  

  

   Of course, you can also write the recursive version in Rust, but this usually isn't such a great idea. Recursion in imperative languages can quickly get out of hand: every call adds a new stack frame, and a deeply recursive function can blow the stack (the infamous
   
    stack overflow
   
   ).
  

  

   On the BEAM there is no fixed-size stack, so runaway recursion eats heap memory until the process is killed instead, but the point remains: deep recursions equals trouble. To avoid that problem, compilers for functional languages implement a technique called Tail Call Optimization (TCO), which applies when the recursive call is the last thing the function does. The existing stack frame is then reused instead of stacking a new one, giving performance close to an imperative
   
    while
   
   loop.
   
    
     5
    
   
  

  

   Gleam is type-safe
  

  

   This piece of the slogan is mostly there to answer the obvious question "why Gleam and not Elixir?" (another Erlang-based language). While Elixir is a dynamically-typed language (with gradual typing now!), Gleam was
   
    built
   
   as a statically-typed language with a strong type system: strong types are its
   
    raison d'être
   
   .
  

  

   A
   
    type
   
   in Gleam encompasses both the
   
    enum
   
   and the
   
    struct
   
   concepts in Rust:
  

  

   

    

     Gleam
    

    
// A usual enum
type Directions {
  Left
  Right
}

// A 'struct-like' type
type Person {
  Person(name: String, age: Int)
}

// A combination of both
type MyError {
  Missing
  InvalidQuery(String)
}

   

   

    

     Rust
    

    
enum Directions {
  Left,
  Right
}

struct Person {
  name: String,
  age: i64
}

enum MyError {
  Missing,
  InvalidQuery(String)
}

   

  

  

   Because Gleam types are algebraic data types, they are very useful to ensure undesired states are impossible. A great aspect of Gleam, which will be relevant a little bit later, is that it compiles to
   
    both
   
   the BEAM virtual machine
   
    and
   
   to JavaScript. So you can share these strong type definitions across different applications in both targets. This is particularly handy if you need a web application to communicate with a BEAM app.
  

  

   Gleam is made for systems that scale
  

  

   That, of course, refers to BEAM, the Erlang VM. Unlike languages which target the native system (Rust, Go, C++), a VM provides an extra abstraction layer between the system and the program. In the case of BEAM, that layer is exceptionally good at handling concurrent processes and failures while remaining fast.
  

  

   Gleam makes good use of that, and this is what a concurrent program would look like:
  

  
// Omitted imports
pub fn main() {
  let order_number_and_amounts = [
    #(101, 100),
    #(102, 200),
    #(103, 300)
  ]
  
  order_number_and_amounts
  |> list.each(fn(x) {
    let #(order_no, amount) = x
    let order_description = "Order #" <> int.to_string(order_no)

    // Spawn unlinked: a crashing worker must not take the parent down.
    process.spawn_unlinked(fn() {
      // 101 and 103 will succeed, 102 will crash
      process_order(order_description, amount)
    })
  })

  io.println("All orders dispatched!")

  // Keep the parent alive until the children have had time to run.
  process.sleep(10)
}

fn process_order(order: String, amount: Int) {
  process.sleep(1)
  case amount {
    200 -> panic as "Payment failed!"
    _ -> io.println(order <> " processed successfully")
  }
}

// Stdout
// ----
// All orders dispatched!
// Order #101 processed successfully
// Order #103 processed successfully

  

   What you should take away from this code is that it's the BEAM that handles processes.
  

  

   The call to
   
    process.spawn_unlinked
   
   triggers a new process with no link to its creator, so when order 102 crashes, neither the parent nor siblings are affected. With a plain
   
    process.spawn
   
   the child would be linked to the caller, and that
   
    panic
   
   would have taken the whole program down. If you look closely, I also added
   
    process.sleep(10)
   
   so the parent wouldn't close
   
    before
   
   the children could finish: this is a hack, since the delay is only a guess and a slower child would still be cut off.
  

  

   Thankfully, a great advantage of the BEAM is how easy inter-process communication is, which the following code piece illustrates well:
  

  
// Omitted imports
pub type PaymentError {
  PaymentFailed
}

pub fn main() {
  let parent = process.new_subject()
  let orders = [
    #(101, False),
    #(102, True),
    #(103, False)
  ]

  orders
  |> list.each(fn(x) {
    let #(order_no, should_fail) = x

    process.spawn(fn() {
      // Simulate processing time
      process.sleep(1000)

      // 101 and 103 succeed, 102 fails
      let res = case should_fail {
        True -> Error(PaymentFailed)
        False -> Ok(Nil)
      }

      process.send(parent, #(order_no, res))
    })
  })

  io.println("All orders dispatched!")

  receive_results(list.length(orders), parent)
}

fn receive_results(
  remaining: Int,
  parent: process.Subject(#(Int, Result(Nil, PaymentError))),
) -> Nil {
  case remaining {
    0 -> Nil

    _ -> {
      let #(order_no, res) = process.receive_forever(parent)

      let status = case res {
        Ok(_) -> "successful"
        Error(_) -> "failed"
      }

      io.println(
        "Processing of order #" <> int.to_string(order_no) <> " " <> status <> "!",
      )

      receive_results(remaining - 1, parent)
    }
  }
}

// Stdout
// ----
// All orders dispatched!
// Processing of order #103 successful!
// Processing of order #102 failed!
// Processing of order #101 successful!
//
// The order of the last three lines depends on scheduling.

  

   OTP: the gift that keeps on giving
  

  

   In the paragraph above, I briefly showed how the BEAM virtual machine is great for concurrent programs communicating by message passing. If you're familiar with Go, this is similar to how it handles the same problem with
   
    goroutines
   
   . But the OTP (Open Telecom Platform), the set of libraries that ships with Erlang, is more powerful than that. It provides you with a built-in supervisor-actor paradigm which enables you to create scalable, concurrent services which can crash without taking down the whole application.
  

  

   In a nutshell, the OTP exposes
   
    actors
   
   : lightweight processes that hold state and communicate with each other via messages (like in the example above). When paired with a
   
    supervisor
   
   , the whole application becomes more resilient to any individual actor crashing: the supervisor will monitor processes and restart them as needed. It can also help start/stop groups of actors dynamically.
  

  

   If you're reading this and thinking "uh that sounds a lot like how I used Kubernetes", you're not alone. The OTP model is extremely similar to the controller-pod architecture of Kubernetes and solves a lot of the same problems.
   
    
     6
    
   
   However, in my experience,
   
    a lot
   
   of workflows using Kubernetes don't really need a cluster but still use one (and that's expensive!) because of the added bonus of the distributive experience. For those cases, the OTP provides a really interesting alternative.
  

  

   Let me give you a concrete example. Without going in too much detail, we have a common setup in my team which involves a handwritten Go job scheduler handling some other processes.
  

  

   

    
     
      
      
      
       
        
        
       
       
        
         Scheduler
        
        
         (REST API)
        
       
      
      
       
        
        
       
       
        Worker
       
      
      
       
        
        
       
       
        Worker
       
      
      
       
        
        
       
       
        User interface (web)
       
      
      
       
        
        
        
        
       
       
        User
       
      
      
       
        
        
        
        
       
       
        
         Database
        
        
         (job queue)
        
       
      
      
       
        
        
       
       
        
        
       
       
       
      
      
       
       
       
        HTTP requests
       
      
      
       
       
       
        Registers jobs
       
      
      
       
       
       
        Polls jobs
       
      
      
       
       
       
        Polls jobs
       
      
      
       
       
       
       
       
       
       
       
       
       
      
     
    
   

  

  

   The scheduler, each worker, and the user interface are all pods inside the cluster, managed by Kubernetes. To be honest, this works well, but it does introduce a lot of complexity. First of all, most of these services do not need to be so isolated from each other. The consequence here is that we need duplicate REST APIs in various places to enable communication between different services.
  

  

   What if we wanted to reorganize this within a Gleam application? There are two parts where Gleam would shine here:
  

  
    
   
  1. 
    the OTP would essentially unify all scheduling services as actors within a single application,
   
    2. 
   
  2. 
    the user interface (currently a Node.js app) can be written in Gleam and compiled to JavaScript.
   
    3. 
  

  

   Here is the revised architecture:
  

  

   

    
     
      
      
      
       
        
        
       
       
        Gleam common code
       
      
      
       
        
        
       
       
        Gleam app on BEAM
       
      
      
       
        
        
       
       
        User interface (web)
       
      
      
       
        
        
        
        
       
       
        User
       
      
      
       
        
        
        
        
       
       
        
         Database
        
        
         (job queue)
        
       
      
      
       
        
        
       
       
        
         HTTP server
        
        
         (REST API)
        
       
      
      
       
        
        
       
       
        Worker supervisor
       
      
      
       
        
        
       
       
        Worker
       
      
      
       
        
        
       
       
        Worker
       
      
      
       
        
        
       
       
        
        
       
       
       
      
      
       
       
      
      
       
       
      
      
       
       
       
        HTTP requests
       
      
      
       
       
       
        Persistent jobs
       
      
      
       
       
       
       
       
       
      
     
    
   

  

  

   Within the BEAM application, all actors would communicate via messages:
  

  
    
   
  • 
    the HTTP server receives requests and saves them to the DB,
   
    • 
   
  • 
    the workers would pick up jobs and write the status back to the DB.
   
    • 
  

  

   So instead of handling the deployment of multiple applications in separate pods, you can just let the OTP handle all process management within one VM (for the scheduling part).
  

  

   What does it mean to reuse code between the frontend and the backend?
  

  

   As mentioned before, one of the big advantages of Gleam is that it compiles to JavaScript. So you can bundle shared type definitions between the user interface and the job scheduler instead of keeping duplicate APIs in sync.
  

  

   

    

     shared/job.gleam
    

    
pub type JobStatus {
  Pending
  Running
  Completed
  Failed
}

pub type Job {
  Job(
    id: String,
    name: String,
    status: JobStatus,
  )
}

pub type CreateJobRequest {
  CreateJobRequest(name: String)
}

pub fn new_job(id: String, request: CreateJobRequest) -> Job {
  Job(
    id: id,
    name: request.name,
    status: Pending,
  )
}

   

   

    

     frontend.gleam
    

    
import gleam/json
import shared/job.{type CreateJobRequest, CreateJobRequest}

// `create_job_encoder` lives in shared/job; `client` is your HTTP client
// of choice (gleam_httpc on the BEAM, gleam/fetch in the browser).

pub fn submit_job(name: String) {
  let request = CreateJobRequest(name: name)

  let body = json.to_string(
    job.create_job_encoder(request),
  )

  // POST /api/jobs
  client.post(
    "/api/jobs",
    body,
  )
}

   

   

    

     server.gleam
    

    
import shared/job.{type CreateJobRequest, type Job}

// `Database`, `DatabaseError` and `generate_id` stand in for your
// database layer and ID generator.

pub fn create_job_handler(
  request: CreateJobRequest,
  db: Database,
) -> Result(Job, DatabaseError) {
  let id = generate_id()
  let created_job = job.new_job(id, request)

  // Persist as Pending in PostgreSQL.
  database.insert_job(db, created_job)
  |> result.map(fn(_) { created_job })
}

   

  

  

   Gleam: the bad
  

  

   Every language has its flaws, and it's time for some honest feedback on Gleam. I don't pretend I have much experience with the language yet, so if any of these complaints feel unfair to you, feel free to
   
    correct me
   
   . So far, these are the things I noticed:
  

  
    
   
  • 
    the ecosystem is small. This is not Gleam's fault per se, just a consequence of being a young language,
    
     
      7
     
    
    and there are mitigating factors such as the possibility to use
    
     external
    
    functions quite easily (Erlang, Elixir on BEAM, JavaScript on its own runtime) directly from Gleam. Yet, the community itself favours Gleam-first packages and as of today, there are some gaps in package variety.
   
    • 
   
  • 
    The language is
    
     too simple
    
    . Well, to be honest I don't
    
     agree
    
    per se with this, I like it like this. But I totally understand that the lack of macros or other complex features can put a few people off (for example, I read that
    
     currying
    
    is dearly missed).
   
    • 
   
  • 
    The BEAM virtual machine is an
    
     excellent
    
    target, but it's also a peculiarity. I couldn't really name any big company/system using it. Yet, a quick search shows that WhatsApp, Discord and Pinterest, as well as Cisco, Nintendo, and even the NHS rely on it. Erlang and BEAM are quietly powering huge platforms due to their reliability, but it's not as flashy as "Made in Rust" marketing. Where Rust had Mozilla, Go had Google and Java had Oracle, there isn't a big tech player pushing for Gleam/Erlang right now.
   
    • 
  

  

   Of course this is a very biased account. I think I'm missing a lot of flaws in the language itself, flaws that will show themselves once the honeymoon period is over. But for now, I'm having a blast with Gleam, and I can only encourage you to give it a try too! I'm sure just like me, you'll have a lot of fun!
  

 




        

      

    
    

        

          
Quality Jobs, Democracy and a Decent Future Now! ITUC Stands With Young People Worldwide

        

        

          Portside
        

	

	  portside.org
	

        

          2026-11-09 22:32:25
        

        

          
            

          
          

            Quality Jobs, Democracy and a Decent Future Now! ITUC Stands With Young People Worldwide

Stephanie

Mon, 11/09/2026 - 22:32

...
          

        

        

          
Original Article

          

 

  

   
    
     Quality Jobs, Democracy and a Decent Future Now! ITUC Stands With Young People Worldwide
    
   
   
    Published
    
   
   

    

     

      
     

     

      AFP CHRISTOPHE ARCHAMBAULT
     

    

    

     

      Across Europe, Asia, Africa and Latin America, youth-led protests are exposing two devastating trends that are fuelling frustration among young people worldwide:
     

     
    
      
  • 
       Education systems and economies are failing students and young workers. Costs are rising, quality is declining and the lack of decent job opportunities is making young people feel that building a future is impossible.
      
    • 
      
  • 
       Governments are failing to address these challenges, either refusing to take responsibility or actively insulting protesters and repressing non-violent demonstrations.
      
    • 
     

     

      
       Shared demands for a better future
      
     

     

      Although circumstances differ between countries, young people across these movements are voicing shared demands that reflect the priorities of workers and trade unions worldwide:
     

     
    
      
  • 
       
        Quality public education and services.
       
       End austerity, increase investment in public education and healthcare, and guarantee accessible, affordable and high-quality services for all.
      
    • 
      
  • 
       
        Decent work and fair wages.
       
       Create decent job opportunities for young people, guarantee fair pay, job security and social protection, and ensure that education leads to decent work.
      
    • 
      
  • 
       
        Affordable living conditions.
       
       Address the rising cost of housing, food, energy and other essentials, and ensure that wages allow young people to live in dignity.
      
    • 
      
  • 
       
        Democracy and accountability.
       
       Tackle corruption, ensure transparency in public decision-making and guarantee young people’s meaningful participation in decisions affecting their future.
      
    • 
      
  • 
       
        Fundamental rights and freedoms.
       
       End the repression of peaceful demonstrations, protect freedom of expression and assembly, and guarantee democratic trade union rights such as freedom of association.
      
    • 
     

     

      
       Young trade unionists at the forefront
      
     

     

      Many of these young people are committed trade unionists and are part of the ITUC’s global membership of 200 million workers. Young trade unionists are helping to turn frustration into collective action, linking demands for better education and decent job opportunities with the defence of democracy, public services and workers’ rights.
     

     

      Speaking at ITUC webinar,
      
       Fight For Democracy: Young Workers Organising for the Future
      
      , Harsha Shelke from HMS India said: “Students are losing hope and trust over the education system in India. We are focusing on helping young people to know what is right and what is wrong and what they deserve.
     

     

      “The higher the number, the stronger the fight. Solidarity can bring more attention and more power and better results against the things we are fighting.”
     

     

      Mabel Paladines from CEOSL Ecuador added: “At this moment we have a right-wing government. Education funding has been cut short year after year. In the most recent mobilization, the brutal police killed colleagues who exercised their right to protest. But young workers in Ecuador are strategic. We have a communications strategy, we have a legal strategy with a case before the Constitutional Court, and we occupy the public space and insert ourselves in these debates.”
     

     

      ITUC General Secretary Luc Triangle said: “Young people are demanding what every generation should be able to expect: quality education, decent jobs, affordable living conditions and a voice in shaping their lives. These are key elements of the New Social Contract championed by the ITUC.
     

     

      “These protests are a warning that policies which deny young people opportunities and economic security are unsustainable. Trade unions stand with young people demanding change. Their fight for decent work, democracy and social justice is our fight too.”
     

     

      The ITUC calls on governments to engage in genuine dialogue with young people and their representative organisations, including trade unions, and respond to their demands with concrete commitments to decent work, quality public services, social protection and democratic freedoms.
     

    

   

  

 




        

      

    
    

        

          
CoreWeave bond yield tops 16% as AI credit stress rises

        

        

          Hacker News
        

	

	  www.cnbc.com
	

        

          2026-11-09 22:20:06
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   

    Jonathan Raa | Nurphoto | Getty Images
   

  

  

   

    Debt markets are sending a message to AI data center builders: we're hiking the interest rate on your credit card and may put some new curbs on your credit limit.
   

   

    That analogy comes courtesy of Jefferies global head of equity strategy, Christopher Wood, who put it in a note on Friday: "The most plausible way the AI capex arms race will end is that the credit card will be taken away."
   

   

    That isn't happening yet, but credit markets have been spooked by the new political landscape — seeing more hurdles to data centers under Democratic governors in key states, along with a Democratic-controlled Congress.
   

   

    The poster child for debt stress is neocloud
    
     
      Coreweave
     
     
      
      
     
    
    . The yield on its 2032 bond with a 9.625% coupon has climbed above 16%. Coreweave's five-year credit default swaps spiked above 1,289 basis points on Thursday, widening above their October peak, according to Deutsche Bank. The CDS eased 8% Friday to around 1,155.
   

  

  

   

    "We've had plenty of warnings from the credit space," said Jim Reid, Deutsche Bank's global head of macro and thematic research, in a note on Friday. Debt and equities are now moving more in sync, he added, "so we'll have to see if credit goes any further."
   

   

    Investors are demanding more compensation to insure against default among even companies with the strongest balance sheets and credit ratings, including
    
     
      Nvidia
     
     
      
      
     
    
    ,
    
     
      Broadcom
     
     
      
      
     
    
    , and
    
     
      Amazon.com
     
     
      
      
     
    
    .
   

   

    CDS on Nvidia debt is up 76% in the last month. Broadcom's CDS is up 49%, while Amazon's has gained 44%. Their CDS remain low on an absolute basis; Nvidia's spread stood at roughly 139 basis points, compared with about 298 bps for
    
     
      Oracle
     
     
      
      
     
    
    and roughly 1,100 for CoreWeave. A large increase from a low starting point does not imply the same credit risk.
   

   

    Still, rising CDS are a sign that markets want more protection against default among even the largest and healthiest debt issuers. And rising CDS imply higher financing costs down the line.
   

  

  

   

    The market is now grappling with the prospect that at least some data center spending will be delayed or scrapped under incoming Democratic governors in Ohio, Texas, and Georgia, the three states with much of the planned capacity.
   

   

    Moratoriums could impact 45% of planned capacity in the U.S. with a large amount of that in Texas, according to Goldman Sachs. Texas governor-elect Gina Hinojosa has said she's not opposed to data centers but wants a moratorium until the state legislature passes protections for communities.
   

   

    None of these means AI debt financing is collapsing. Goldman tallies five AI bond deals totaling $67 billion since October 29, pushing total hyperscaler debt issuance this year to $296 billion. Goldman forecasts $440 billion of hyperscaler debt issuance next year, plus an additional $300 billion of project-level issuance across investment-grade and high-yield.
   

   

    The Trump administration is vowing to support data centers. National Economic Council Director Kevin Hassett
    
     told CNBC
    
    on Friday that he expects data center growth to continue as forecast, despite Democrats' big election wins.
   

   

    
     What comes next
    
   

   

    The big question now is how quickly AI spending will generate enough cash for hyperscalers to keep investors comfortable with future capex plans. For the neoclouds, any sign of consolidation or retrenchment in capex could result in fewer or shorter contracts for data center compute or delays in prepayments.
   

   

    Goldman analysts said hyperscalers collectively reported negative free cash flow in the third quarter as capital spending exceeded operating cash flow.
   

   

    "Delayed monetization and growth in purchase commitments—which we view as additional and sizable uses of cash, separate from Capex—are the key risks to more debt issuance, subject to market conditions," according to the bank.
   

   

    Peak AI debt issuance may now be closer at hand. Bank of America analysts estimates that AI-related credit issuance will rise 31% from 2026 to 2027, hitting $685 billion, including public and private debt. They then see it falling 23% to $531 billion in 2028.
   

   

    As for the risk? "Downside to these forecasts exists from a potential slowdown in AI infrastructure projects on the back of the Blue Wave, which will reduce capex needs and thus debt market funding," BofA said in a note.
   

   

    
     -CNBC's Nick Wells and Michael Bloom contributed reporting
    
   

  

 




        

      

    
    

        

          
US Supreme Court Clears Way for Trump’s Border Wall in Texas’s Big Bend

        

        

          Portside
        

	

	  portside.org
	

        

          2026-11-09 22:10:42
        

        

          
            

          
          

            US Supreme Court Clears Way for Trump’s Border Wall in Texas’s Big Bend

Ira

Mon, 11/09/2026 - 22:10

...
          

        

        

          
Original Article

          

 

  

   
  

  

   A portion of border wall under construction in the Big Bend region, near Sierra Blanca, Texas, in September 2026.   | John Locher/AP
  

 

 

  

   The
   
    US supreme court
   
   has allowed Donald Trump to continue his administration’s construction of a border wall in Texas’s Big Bend region, including parts of Big Bend national park.
  

  

   In an unsigned, five-page
   
    ruling
   
   , the nation’s highest court granted the Trump administration’s emergency request to suspend a lower court order that had
   
    temporarily stopped
   
   the project last month.
  

  

   Liberal justice Ketanji Brown Jackson was the only member of the nine-member court to dissent from the ruling.
  

  

   The justices wrote that the case’s plaintiffs, which include the Center for Biological Diversity, a Big Bend river guide and a church preservation group, “claim that construction in the Big Bend sector will diminish their ability to use and enjoy the area”.
  

  

   However, they noted: “But Congress’s enactment of [immigration law] – which permits the secretary [of homeland security] to waive the requirements of environmental-protection and other conservation laws – reflects a clear preference for expeditious border construction over the very harms respondents assert.
  

  

   “The government’s interest therefore outweighs any aesthetic, recreational, and environmental harm alleged by respondents,” the justices said.
  

  

   The
   
    Trump administration
   
   plans to construct more than 300 miles of six-foot-tall vehicle barriers and supporting roads, relying on a 1996 law that authorizes the homeland security secretary to “waive all legal requirements”, including environmental and conservation protections, in areas designated as having high levels of illegal border crossings.
  

  

   The plaintiffs
   
    argue
   
   that the project threatens wildlife and public lands, could destroy “iconic sections” of the Rio Grande’s protected river corridor, and would undermine the “carefully wrought web of laws meant to protect a vast universe of biological, historic, cultural, and other interests”.
  

  

   The border wall plans have also faced
   
    bipartisan opposition
   
   from local residents, many of whom warn that construction could threaten their livelihoods and disrupt their communities.
  

  

   A Customs and Border Protections
   
    map
   
   shows plans for barriers and patrol roads across Big Bend national park, including remote areas that would require extensive dynamite blasting. Construction is also planned in isolated canyons where there have been no documented unauthorized vehicle crossings and where vehicles cannot reach the US-Mexico border, the Center for Biological Diversity
   
    noted.
   
  

  

   
    According to
   
   Rodney Scott, the CBP commissioner, the wall, which is being
   
    built out at about 12 miles
   
   a week, is expected to be completed by the end of Trump’s second term.
  

  

   The Center for Biological Diversity condemned the supreme court’s decision,
   
    saying:
   
   “This horrific decision clears the way for contractors to bulldoze pristine desert and dynamite canyon walls before the courts have even decided whether this destruction is legal. They’re signing off on the permanent destruction of the wildest place in Texas, and the theft of a great American river from all of us.
  

  

   “The destruction we’ve already seen in Big Bend unleashed a firestorm of outrage so severe that the administration was forced to pause its plans. If the bulldozers return now, public opposition will only grow … The damage done to Big Bend will be felt for future generations of Texans and Americans, and this administration will bear responsibility for the natural heritage we lose,” the center added.
  

  

   CBP has
   
    awarded
   
   five contracts worth more than $6bn for border security upgrades in Big Bend, including 30-ft steel fencing, vehicle barriers and surveillance technology, which the agency calls its “smart wall”.
  

  

   Following a federal judge’s ruling that temporarily halted the construction in October, CBP
   
    said
   
   at the time: “We stand by our assessment and remain confident in our legal authorities to secure the border while preserving the unique landscape of the Big Bend region.”
  

  

   The Guardian has reached out to CBP for comment on the supreme court’s latest ruling.
  

 




        

      

    
    

        

          
California voters fail to pass proposed one-time tax on billionaires’ wealth

        

        

          Guardian
        

	

	  www.theguardian.com
	

        

          2026-11-09 21:54:54
        

        

          
          

            Campaign over Prop 40, as measure was known, was most expensive in state history, flush with Silicon Valley dollars California billionaires won a contentious ballot measure campaign, defeating a proposed one-time tax on their wealth. The bruising campaign over Proposition 40 was the most expensive i...
          

        

        

          
Original Article

          

 

  

   California billionaires won a contentious ballot measure campaign, defeating a proposed one-time tax on their wealth.
  

  

   The bruising campaign over Proposition 40 was the most expensive in state history and witness to back-and-forth dealing from tech billionaires and democratic leaders, including Gavin Newsom, the governor, who steadfastly opposed the measure. While supporters of Prop 40 cast it as a solution to drastic healthcare cuts from Trump’s One Big Beautiful Bill Act, opponents led by prosperous billionaires mounted an influential campaign saying the billionaire tax was instead “an everyone tax”.
  

  

   This result could hamper nationwide momentum on demands that billionaires pay their fair share and states enacting new laws to tax the ultra-wealthy.
  

  

   Prop 40 proposed a one-time 5% tax on all individuals in California with a net worth of more than $1bn as of 1 January 2026. It was sponsored by the healthcare union SEIU-United Healthcare Workers West, and dictated that the proceeds from the tax would fund healthcare programs, along with some education and food assistance.
  

  

   The state’s major unions, and progressive politicians such as Bernie Sanders, the Vermont senator, and Ro Khanna, a California congressman, backed Prop 40. But both the Democratic and Republican candidates for governor, as well as organizations such as Planned Parenthood Affiliates of California, a lobbying branch of the healthcare group, opposed it – pointing to its structure as a one-off tax that would only fund certain healthcare programs. Prop 40’s most vocal critics, however, were the state’s billionaires.
  

  

   Donors to the opposition campaign
   
    were a who’s who of Silicon Valley
   
   , including executives from Google, Palantir, DoorDash, Stripe and Reddit, along with several prominent venture capitalists. The biggest donor, by far, was Sergey Brin, a Google co-founder, who contributed at least $132m to fight the tax, according to campaign finance filings.
  

  

   All told, the billionaires mounted a nearly $425m battle against Prop 40, making it the most expensive opposition campaign in state history. In the first two weeks of October, spending surpassed $2.5m a day, according to the most recent
   
   
   campaign finance filings.
  

  

   Part of the opposition campaign’s strategy was mounting two separate counter-measures on the ballot, Proposition 41 and 42. Prop 41 directly targeted the billionaire tax, while Prop 42 was a general proposal on limiting certain new taxes and would ban any taxation on billionaire wealth. If either measure received more yes votes than Prop 40, they would stop the billionaire tax from taking effect – even if it passed.
  

  

   Supporters of the billionaire tax called Props 41 and 42 “poison pills”.
  

 




        

      

    
    

        

          
Australia to introduce mandatory reporting after OpenAI hack to combat artificial intelligence ‘going rogue’

        

        

          Guardian
        

	

	  www.theguardian.com
	

        

          2026-11-09 21:31:08
        

        

          
          

            Government flags criminal law changes to ensure companies can’t argue in future ‘that someone didn’t know the computer was loaded’ OpenAI won’t face criminal penalties over the Medicare hack but the prime minister has flagged changes to Australia’s criminal law to crack down on future breaches by ar...
          

        

        

          
Original Article

          

 

  

   OpenAI won’t face criminal penalties over the Medicare hack but the prime minister has flagged changes to Australia’s criminal law to crack down on future breaches by artificial intelligence companies.
  

  

   Anthony Albanese on Tuesday released the recommendations of a “rapid review” into the June breach but not the findings or the report itself.
  

  

   A key recommendation is for the attorney general’s department, the Australian federal police and home affairs to consider reforming the law to introduce “penalties for egregious regulatory non-compliance” and a “failure to prevent” offence which would criminalise developing an AI model that engaged in harmful conduct while failing “to take reasonable steps to prevent that harm”.
  

  

   
   
  

  

   The review recommended the federal government “consider mandatory, time-bound AI safety reporting, including but not limited to misaligned behaviour or agentic cyber incidents”.
  

  

   The home affairs minister, Tony Burke, told reporters “we need to make sure that our laws and our systems keep pace with the technology and also make sure that we’re able to use the technology to find vulnerabilities before others do”.
  

  

   “The mandatory reporting, when artificial intelligence goes rogue, gives us a chance to be able to make sure that when this happens, the reporting occurs and occurs immediately,” Burke said in Canberra alongside the PM.
  

  

   On the “concept of looking at how we can update our criminal law”, Burke said: “It should never be the case that there’s an argument that someone didn’t know the computer was loaded.”
  

  

   “We need to make sure that the criminal law is up to date for how this new technology is able to act.”
  

  

   Albanese on Tuesday characterised OpenAI’s breach of Services Australia as “minor” in terms of the implications for personal privacy.
  

  

   “The clear indication is that no information was got that involves people’s personal details,” the prime minister told reporters in Canberra.
  

  

   “All of that was confirmed essentially ... but that doesn’t mean that it wasn’t a serious issue and that in other areas there might be more serious implications.”
  

  

   The review made 18 recommendations. Albanese said “we accept all of the recommendations and we’ve commenced work to implement them”.
  

  

   Albanese did not directly answer a question about whether the OpenAI incident in June would have breached the proposed new laws if they were in place.
  

  

   The AI agent developed by OpenAI
   
    accessed Services Australia data and three other
   
   systems in June.
  

  

   The company didn’t notify the Australia government until mid-September despite becoming aware of the incident itself in August.
  

  

   Guardian Australia revealed last month OpenAI used AI to help write the email to notify Australian authorities.
  

  

   Albanese said the government would set up a new AI safety regulator.
  

  

   Labor would consider six key obligations on AI companies, including:
  

  
    
   
  • 
    
    
     maintaining security controls across all stages of development and deployment;
    
    
   
    • 
   
  • 
    
    
     identify and manage serious risks associated with their models;
    
    
   
    • 
   
  • 
    
    
     provide mandatory notification of incidents to the Australian government rapidly;
    
    
   
    • 
   
  • 
    
    
     allow independent evaluation of their models;
    
    
   
    • 
   
  • 
    
    
     maintain and publish safety and security frameworks to ensure good governance, risk management, and transparency;
    
    
   
    • 
   
  • 
    
    
     and respond to updated standards and rules as technologies change.
    
    
   
    • 
  

 




        

      

    
    

        

          
Tabernetes: Kubernetes in your browser tab

        

        

          Lobsters
        

	

	  jkroepke.de
	

        

          2026-11-09 20:59:28
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   Tabernetes is a real Kubernetes v1.37 control plane. Not a simulator. kube-apiserver, kube-controller-manager, kube-scheduler and kubectl are the upstream Go code, compiled to WebAssembly into one binary. The only replaced part is etcd: a small in-memory implementation of the etcd v3 API. Everything runs in your browser tab. Reload the page and the cluster is gone.
  

  

   A control plane without nodes is boring. Type
   
    join
   
   and start the printed
   
    docker run
   
   command. The container runs a kubelet and containerd and connects to your browser with WebRTC. Then
   
    kubectl get pods -A
   
   shows flannel, kube-proxy and CoreDNS on a real node.
  

  

   And yes, it runs Doom. After a join, type
   
    doom
   
   .
   
    KubeDoom
   
   starts on the node, and every pod in the default namespace is a monster. Shoot one, and KubeDoom deletes the pod. The Deployment brings it back, of course.
  

  

   Your browser tab is a node, too. The control plane runs in a shared worker, and every tab of this page joins the cluster as a node. Open the page in a second tab, and
   
    kubectl get nodes
   
   shows
   
    tab-2
   
   . Close the first tab, and the cluster keeps running.
  

  

   Type
   
    llm
   
   , and a Deployment runs a language model on the GPU of your tab, with
   
    WebLLM
   
   and WebGPU. The tab pulls the model like an image, and
   
    kubectl describe pod
   
   shows the events. Then
   
    kubectl exec -it deploy/llm -- chat
   
   talks to it. Close the tab, and the pod moves to another tab with WebGPU.
  

  

   

    Needs WebGPU
   

   

    

     
      llm
     
     needs a browser with WebGPU, for example a current Chrome or Edge. The first start downloads about 1 GB of model weights from Hugging Face. After that, they come from the browser cache.
    

   

  

  

   The boot takes around 15 seconds. WebAssembly in the browser is single threaded, so the whole control plane shares one CPU core. The source is in the
   
    blog repository
   
   .
  

 




        

      

    
    

        

          
Formalizing CPython

        

        

          Hacker News
        

	

	  broyojo.com
	

        

          2026-11-09 20:56:48
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   

    AI agents wrote 613,318 lines of Lean that copy Python's internals line by line, tested every piece against the real Python, had a computer check every proof, and turned up 418 bug reports in Python along the way.
   

  

  

   

    

     

      
       CPython
      
      · Objects/rangeobject.c
     

     
static unsigned longget_len_of_range(long lo, long hi, long step){    assert(step != 0);    if (step > 0 && lo < hi)        return 1UL + (hi - 1UL - lo) / step;    else if (step < 0 && lo > hi)        return 1UL + (lo - 1UL - hi) / (0UL - step);    else        return 0UL;}

    

    

     

      
       Lean copy
      
      · RangeSlice/Model.lean
     

     
def getLenOfRange (lo hi step : Int) : Int :=  if step > 0 ∧ lo < hi then    uadd 1 (usub (usub (toU hi) 1) (toU lo) / toU step)  else if step < 0 ∧ lo > hi then    uadd 1 (usub (usub (toU lo) 1) (toU hi)              / usub 0 (toU step))  else 0 -- step ≠ 0 is assumed by every proof-- uadd, usub: C's unsigned arithmetic,-- which wraps around past 2^64

    

   

   

    A function from CPython's C source (left) and the Lean copy an agent wrote of it (right). Hover over a line to see its counterpart.
   

  

  

   

    TL;DR
   

   
    
    
  • 
     We pointed Opus 5.5 at CPython, the program that runs almost all Python code, and had it rewrite its functions in
     
      Lean
     
     , a language for writing machine-checked proofs.
    
    • 
    
  • 
     Each rewrite copies the original line by line and is tested against real Python on tens of thousands of inputs before anyone tries to prove anything about it.
    
    • 
    
  • 
     A function only counts once a second agent, which didn't write it, checks the work and agrees it holds up. 4,071 functions have passed that check so far.
    
    • 
    
  • 
     The result is 613,318 lines of Lean across 1,539 files, with 18,898 theorems and lemmas, all checked by Lean's proof checker on every build.
    
    • 
    
  • 
     Along the way the proofs turned up 418 bug reports. Most are small, but about 55 can crash the interpreter or corrupt memory from ordinary Python code.
    
    • 
   

  

  

   

    
     
     
     Checked and accepted
    
    
     
     
     Written, not yet accepted
    
    
     
     
     Not started
    
   

   
    
    
  • 
     
      All of CPython
     
     
      
      
      
      
     
     
      16%
     
    
    • 
    
  • 
     
      Interpreter core
     
     
      
      
      
      
     
     
      10%
     
    
    • 
    
  • 
     
      Built-in types
     
     
      
      
      
      
     
     
      35%
     
    
    • 
    
  • 
     
      C modules
     
     
      
      
      
      
     
     
      19%
     
    
    • 
    
  • 
     
      Parser
     
     
      
      
      
      
     
     
      31%
     
    
    • 
    
  • 
     
      Grammar rules
     
     
      
      
      
      
     
     
      100%
     
    
    • 
    
  • 
     
      Standard library
     
     
      
      
      
      
     
     
      9%
     
    
    • 
   

   

    How much of each part of CPython 3.15.2 has been copied, tested, proved and accepted by review. Code with nothing to check, such as memory bookkeeping, is left out.
   

  

  

   

    Why bother
   

   

    Python doesn't have a precise written definition. There is a reference manual, but in practice "Python" means whatever CPython does, and CPython is hundreds of thousands of lines of C plus a large standard library. The manual covers normal use. It says little about the odd cases, and that's where bugs hide: an object that changes a dictionary while that dictionary is searching for it, an error thrown halfway through an update, a number one past the largest the C code was written for.
   

   

    Writing a proof about a function forces you to say exactly what it does in all of those cases. You can't leave anything vague, because the proof checker won't accept it. That makes proofs a good way to find the places where the code doesn't do what everyone assumes.
   

   

    We wanted to see how far this goes on a code base as large and old as CPython, and whether the results stay trustworthy when most of the work is done by AI.
   

   

    How it works
   

   

    Every function goes through the same four steps.
   

  

  

   
    
    
  1. 
     
      Copy
     
     
      Rewrite the function in Lean, following the original code line by line, including its error messages and its odd corners.
     
    
    2. 
    
  2. 
     
      Test
     
     
      Run the copy and the real Python side by side on at least 50,000 tricky inputs. Any disagreement means the copy is wrong.
     
    
    3. 
    
  3. 
     
      Prove
     
     
      State something that should always be true and have the computer check the proof. If it's actually false, prove that instead.
     
    
    4. 
    
  4. 
     
      Check
     
     
      A second agent that didn't do the work reviews it against the original and tries to break it. Only what survives counts.
     
    
    5. 
   

  

  

   The code at the top of this page is step one for a small piece of CPython: the C function that works out how many numbers are in a
   
    range
   
   , next to its Lean copy. The copy keeps the C code's exact arithmetic, including how its numbers wrap around when they get too big. The proof about it shows that this function, the slower version CPython uses for very large numbers, and the code that chooses between them always give the same, correct count.
  

  

   

    Proofs that prove nothing
   

   

    The hardest part wasn't getting AI agents to write proofs. It was getting proofs that actually mean something.
   

   

    Our first attempt asked the agents for breadth: copy every function and prove at least one thing about each. They did. Then a separate review found that fewer than half of the functions it checked held up, and in one file only 21%. The proofs were all correct. They just didn't say anything useful. For example, "if this function returns a number, the number is at least zero" is true, but a function that always crashes also satisfies it.
   

   

    So the reviewer now asks one question about every proof:
    
     could a broken version of the function pass it too?
    
   

  

  

   

    Two true statements about the same function. The first one lets every broken version through, so a function whose only proof looks like it doesn't count.
   

  

  

   Fixing a weak proof usually means going back and making the copy more realistic, for example letting a user's code throw an error in the middle of a function. The charts below show how that went for ten files. Each point is one round of review. The lines sometimes go down: when a reviewer finds that an accepted proof is wrong about real Python, everything that relied on it is taken back out.
  

  

   

    

     Functions accepted
    

    

     

      
       
       
       
       
       
        100%
       
       
        0%
       
       
        review 1
       
       
        review 5
       
       
       
       
        
         review 1: 0 of 142 accepted
        
       
       
        
         review 2: 2 of 142 accepted
        
       
       
        
         review 3: 41 of 142 accepted
        
       
       
        
         review 4: 130 of 142 accepted
        
       
       
        
         review 5: 135 of 142 accepted
        
       
      
      

       
        Objects/typeobject.c
       
       
        
         135 of 142
        
        accepted · 5 reviews
       
      

     

     

      
       
       
       
       
       
        100%
       
       
        0%
       
       
        review 1
       
       
        review 5
       
       
       
       
        
         review 1: 1 of 56 accepted
        
       
       
        
         review 2: 18 of 56 accepted
        
       
       
        
         review 3: 54 of 56 accepted
        
       
       
        
         review 4: 55 of 56 accepted
        
       
       
        
         review 5: 56 of 56 accepted
        
       
      
      

       
        Objects/genobject.c
       
       
        
         56 of 56
        
        accepted · 5 reviews
       
      

     

     

      
       
       
       
       
       
        100%
       
       
        0%
       
       
        review 1
       
       
        review 7
       
       
       
       
        
         review 1: 31 of 46 accepted
        
       
       
        
         review 2: 42 of 46 accepted
        
       
       
        
         review 3: 44 of 46 accepted
        
       
       
        
         review 4: 45 of 46 accepted
        
       
       
        
         review 5: 44 of 46 accepted
        
       
       
        
         review 6: 45 of 46 accepted
        
       
       
        
         review 7: 46 of 46 accepted
        
       
      
      

       
        Objects/setobject.c
       
       
        
         46 of 46
        
        accepted · 7 reviews
       
      

     

     

      
       
       
       
       
       
        100%
       
       
        0%
       
       
        review 1
       
       
        review 5
       
       
       
       
        
         review 1: 31 of 48 accepted
        
       
       
        
         review 2: 39 of 48 accepted
        
       
       
        
         review 3: 42 of 48 accepted
        
       
       
        
         review 4: 43 of 48 accepted
        
       
       
        
         review 5: 45 of 48 accepted
        
       
      
      

       
        Modules/_json.c
       
       
        
         45 of 48
        
        accepted · 5 reviews
       
      

     

     

      
       
       
       
       
       
        100%
       
       
        0%
       
       
        review 1
       
       
        review 9
       
       
       
       
        
         review 1: 21 of 39 accepted
        
       
       
        
         review 2: 30 of 39 accepted
        
       
       
        
         review 3: 35 of 39 accepted
        
       
       
        
         review 4: 34 of 39 accepted
        
       
       
        
         review 5: 33 of 39 accepted
        
       
       
        
         review 6: 34 of 39 accepted
        
       
       
        
         review 7: 29 of 39 accepted
        
       
       
        
         review 8: 36 of 39 accepted
        
       
       
        
         review 9: 37 of 39 accepted
        
       
      
      

       
        Lib/enum.py
       
       
        
         37 of 39
        
        accepted · 9 reviews
       
      

     

     

      
       
       
       
       
       
        100%
       
       
        0%
       
       
        review 1
       
       
        review 3
       
       
       
       
        
         review 1: 11 of 38 accepted
        
       
       
        
         review 2: 31 of 38 accepted
        
       
       
        
         review 3: 37 of 38 accepted
        
       
      
      

       
        Lib/random.py
       
       
        
         37 of 38
        
        accepted · 3 reviews
       
      

     

     

      
       
       
       
       
       
        100%
       
       
        0%
       
       
        review 1
       
       
        review 2
       
       
       
       
        
         review 1: 9 of 43 accepted
        
       
       
        
         review 2: 41 of 43 accepted
        
       
      
      

       
        Objects/abstract.c
       
       
        
         41 of 43
        
        accepted · 2 reviews
       
      

     

     

      
       
       
       
       
       
        100%
       
       
        0%
       
       
        review 1
       
       
        review 2
       
       
       
       
        
         review 1: 19 of 33 accepted
        
       
       
        
         review 2: 33 of 33 accepted
        
       
      
      

       
        Objects/rangeobject.c
       
       
        
         33 of 33
        
        accepted · 2 reviews
       
      

     

     

      
       
       
       
       
       
        100%
       
       
        0%
       
       
        review 1
       
       
        review 2
       
       
       
       
        
         review 1: 14 of 33 accepted
        
       
       
        
         review 2: 31 of 33 accepted
        
       
      
      

       
        Lib/pickletools.py
       
       
        
         31 of 33
        
        accepted · 2 reviews
       
      

     

     

      
       
       
       
       
       
        100%
       
       
        0%
       
       
        review 1
       
       
        review 2
       
       
       
       
        
         review 1: 29 of 40 accepted
        
       
       
        
         review 2: 35 of 40 accepted
        
       
      
      

       
        Modules/binascii.c
       
       
        
         35 of 40
        
        accepted · 2 reviews
       
      

     

    

    

     Rounds of review →
    

   

   

    Share of each file's reviewed functions accepted after each round of review, taken from the project's history. Each point is one review; the scale is the same in every chart, from 0% to all of the functions reviewed in that file. Accepted functions include ones the reviewer confirmed have nothing to check, such as memory bookkeeping.
   

  

  

   

    When a correct proof is wrong anyway
   

   

    A checked proof guarantees that a statement follows from the copy. It doesn't guarantee the copy matches real Python, and testing only covers the inputs you thought to try. So every accepted statement is also run against real Python. That caught several proofs that were valid and still wrong.
   

   

    The 16-terabyte string
   

   

    The copy of Python's fast JSON encoder assumed memory requests always succeed. So it "proved" the encoder could build its indentation strings for any nesting depth, including one that needs 16 terabytes of memory. Real Python runs out of memory. The fixed copy now treats every memory request as something that can fail.
   

   

    Nine extra steps, just once
   

   

    A proof said Python's pickle module never goes deeper than a certain number of nested calls. That turned out true except in a brand-new Python process. There, the first time it encodes a string, it quietly loads a text codec, and that load uses nine more nested calls. Our tests never saw it, because the test harness had already loaded the codec.
   

   

    Error types have families
   

   

    In Python, catching a
    
     TypeError
    
    also catches any more specific error built on top of it. Three separate copies checked an error's exact name instead. All three had proofs that a custom error type could break.
   

   

    Memory that comes back
   

   

    The copy of Python's
    
     set
    
    assumed that once memory is freed, the same address never comes back. Real memory allocators reuse addresses all the time. CPython uses a "did the address change?" check to notice when user code has swapped out the set's internals. With reuse, that check can be fooled. Fixing the copy turned an accepted proof into a real memory bug, now one of our bug reports.
   

   

    What we found
   

   

    When a proof fails because Python itself is wrong, and not the copy, we write it up as a bug report. Each report includes a short script that shows the bug on Python 3.15.2 (for most, also on the development version), a search for duplicates already reported, and an honest rating of how much it matters.
   

  

  

   
    
    
  • 
     
      C and Python versions disagree
     
     
     
     
      129
     
    
    • 
    
  • 
     
      Other
     
     
     
     
      122
     
    
    • 
    
  • 
     
      Wrong result
     
     
     
     
      56
     
    
    • 
    
  • 
     
      Crash
     
     
     
     
      28
     
    
    • 
    
  • 
     
      Memory corruption
     
     
     
     
      27
     
    
    • 
    
  • 
     
      Doesn't match the docs
     
     
     
     
      26
     
    
    • 
    
  • 
     
      Wrong error or message
     
     
     
     
      18
     
    
    • 
    
  • 
     
      Missing input check
     
     
     
     
      12
     
    
    • 
   

   

    418 bug reports by type. "C and Python versions disagree" means a module has two implementations, a fast one in C and a backup in Python, and they give different answers to the same call.
   

  

  

   Most are small: an error message that's wrong, an edge case that behaves differently from the documentation, two versions of a function that disagree. About 55 are more serious and can crash Python or corrupt its memory using nothing but normal Python code, usually by having user code change a container while C code is in the middle of using it. Python doesn't treat running hostile Python code as a security boundary, so these are ordinary bugs. The ones not already on CPython's tracker are being reported to the project, starting with this post. Six small examples of different kinds:
  

  

   

    

     
      Crash
     
    

    

     A dictionary call that crashes Python
    

    

     Calling
     
      setdefault
     
     on an object's attribute dictionary with a
     
      StrEnum
     
     key crashes the interpreter, if another object of the same class has that attribute and this one doesn't.
    

    
class Key(StrEnum):
    NAME = "name"
class User: pass
a = User(); a.name = "ada"
b = User(); b.age = 36
vars(b).setdefault(Key.NAME, "anon")
# Segmentation fault

   

   

    

     
      Memory corruption
     
    

    

     An XML edit that corrupts memory
    

    

     Assigning to a backwards slice of an ElementTree element should insert, as it does for a list. Instead it duplicates one child without taking a reference and loses another.
    

    
e = ET.Element("root")
e[:] = [ET.Element(f"a{i}") for i in range(7)]
e[5:2] = [ET.Element("X")]
[c.tag for c in e]
# 'a2' appears twice, 'a4' is gone

   

   

    

     
      Wrong error
     
    

    

     An email header that breaks the parser
    

    

     A Message-ID with a space inside square brackets makes Python's email parser fail with an internal error. The header comes from whoever sent the email.
    

    
msg = email.message_from_string(
    "Message-ID: <a@[ x]>\n\nhi\n",
    policy=policy.default)
msg["Message-ID"]
# UnboundLocalError

   

   

    

     
      Silently wrong result
     
    

    

     Base32 padding that depends on position
    

    

     New in Python 3.15, the base32 decoder can ignore chosen characters. If
     
      =
     
     is one of them, where it appears still changes the result.
    

    
a2b_base32(b"AAAAAAA",  ignorechars=b"=")
# Error: Incorrect padding
a2b_base32(b"AAAA=AAA", ignorechars=b"=")
# b'\x00\x00\x00\x00'

   

   

    

     
      Missing error
     
    

    

     An enum error that disappears
    

    

     Giving an enum value to a second member should raise an error. If the class's
     
      __repr__
     
     is broken, the error is swallowed and the call quietly does nothing.
    

    
class W(Enum):
    A = 1; B = 2
    def __repr__(self): return 5
W.B._add_value_alias_(3)
W.A._add_value_alias_(3)  # returns None

   

   

    

     
      C and Python disagree
     
    

    

     Two picklers, two limits
    

    

     Python has a C pickler and a pure-Python one. They give up at different nesting depths. This difference was first reported in 2008 and is still open.
    

    
v = []
for _ in range(400): v = [v]
pickle.dumps(v, 5)    # works
pickle._dumps(v, 5)   # RecursionError

   

  

  

   

    Every report, with its script, is in the
    
     repository
    
    .
   

   

    Do this for your own project
   

   

    None of this is specific to Python. It works for anything with source code you can read and a working version you can run: another language, a library, a file format, a compiler. What made the difference for us:
   

   
    
    
  1. 
     
      Pick one exact version
     
     and stick to it. Every copy points at specific lines in that version.
    
    2. 
    
  2. 
     
      List everything first.
     
     Count progress against the full list, so nothing gets skipped quietly.
    
    3. 
    
  3. 
     
      Copy the code, not the documentation.
     
     A copy written from the docs agrees with the docs, and the bugs are where the code and the docs disagree.
    
    4. 
    
  4. 
     
      Let user code misbehave.
     
     Model callbacks that throw errors or change things mid-operation. That's where the worst bugs were.
    
    5. 
    
  5. 
     
      Test before you prove.
     
     Proving things about a wrong copy wastes time.
    
    6. 
    
  6. 
     
      When something is false, keep the counterexample.
     
     Don't water the statement down until it becomes provable.
    
    7. 
    
  7. 
     
      Check proved statements against the real thing.
     
     A valid proof about a wrong copy is the most misleading result you can get.
    
    8. 
    
  8. 
     
      Count only what an independent reviewer accepts,
     
     and have that reviewer ask whether a broken version would pass.
    
    9. 
   

   

    The instructions our agents worked from are in the repository and meant to be reused:
    
     AGENTS.md
    
    for the agents doing the work,
    
     REVIEW_PROMPT.md
    
    for the reviewers, and the full list of functions with their status in
    
     coverage/methods
    
    .
   

   

    Related work
   

   

    The closest project is
    
     julia-in-lean
    
    , which did this for the Julia language and directly inspired this one
    
     
      1
     
    
    . It modelled Julia's standard library in Lean, tested the models against Julia, recorded about 400 bugs and filed 75. Its finding that 128 of 130 quick proofs had quietly assumed away the hard case shaped our review rules. A recent paper models NVIDIA's
    
     PTX
    
    GPU instruction set in Lean to prove GPU kernels correct
    
     
      2
     
    
    , building on earlier formal work on PTX's memory model
    
     
      3
     
    
    .
   

   

    For Python specifically,
    
     λπ
    
    
     
      4
     
    
    and a
    
     K framework
    
    semantics of Python 3.3
    
     
      5
     
    
    described the language mathematically; this project copies CPython's actual code instead. Similar efforts exist for JavaScript
    
     
      6
     
     ,
     
      7
     
    
    and WebAssembly
    
     
      8
     
    
    , and CompCert
    
     
      9
     
    
    and seL4
    
     
      10
     
    
    remain the high bar for fully verified software. Comparing two implementations on the same inputs, the testing half of this project, goes back decades
    
     
      11
     
     ,
     
      12
     
    
    .
   

   

    Where it stands
   

   

    The project started on 29 October 2026. 4,071 of the 26,004 functions worth checking (15.7%) have been copied, tested, proved and accepted by review. The Lean code is 613,318 lines in 1,539 files, containing 18,898 theorems and lemmas; 3,834 of the top-level properties are proved and 588 are proved false with a counterexample. Most of Python is still ahead, especially the large part of the standard library written in Python itself. Multithreading is out of scope for now. In these 57 files, every function copied so far has passed review. The 30 with the most accepted functions:
   

   
    
    
  • 
     
      Python/bytecodes.c
     
     
      310
     
    
    • 
    
  • 
     
      Grammar/python.gram
     
     
      278
     
    
    • 
    
  • 
     
      Lib/collections/__init__.py
     
     
      184
     
    
    • 
    
  • 
     
      Lib/_pydecimal.py
     
     
      160
     
    
    • 
    
  • 
     
      Lib/_pydatetime.py
     
     
      150
     
    
    • 
    
  • 
     
      Modules/_struct.c
     
     
      122
     
    
    • 
    
  • 
     
      Objects/longobject.c
     
     
      119
     
    
    • 
    
  • 
     
      Objects/listobject.c
     
     
      114
     
    
    • 
    
  • 
     
      Objects/memoryobject.c
     
     
      107
     
    
    • 
    
  • 
     
      Objects/dictobject.c
     
     
      104
     
    
    • 
    
  • 
     
      Objects/bytesobject.c
     
     
      100
     
    
    • 
    
  • 
     
      Objects/exceptions.c
     
     
      97
     
    
    • 
    
  • 
     
      Objects/unicodeobject.c
     
     
      94
     
    
    • 
    
  • 
     
      Objects/bytearrayobject.c
     
     
      93
     
    
    • 
    
  • 
     
      Modules/arraymodule.c
     
     
      84
     
    
    • 
    
  • 
     
      Lib/_collections_abc.py
     
     
      81
     
    
    • 
    
  • 
     
      Modules/_operator.c
     
     
      73
     
    
    • 
    
  • 
     
      Modules/itertoolsmodule.c
     
     
      72
     
    
    • 
    
  • 
     
      Modules/_collectionsmodule.c
     
     
      64
     
    
    • 
    
  • 
     
      Python/codecs.c
     
     
      61
     
    
    • 
    
  • 
     
      Lib/operator.py
     
     
      59
     
    
    • 
    
  • 
     
      Lib/_pyio.py
     
     
      58
     
    
    • 
    
  • 
     
      Objects/typeobject.c
     
     
      57
     
    
    • 
    
  • 
     
      Lib/weakref.py
     
     
      54
     
    
    • 
    
  • 
     
      Objects/genobject.c
     
     
      46
     
    
    • 
    
  • 
     
      Lib/urllib/parse.py
     
     
      46
     
    
    • 
    
  • 
     
      Parser/action_helpers.c
     
     
      43
     
    
    • 
    
  • 
     
      Modules/_zoneinfo.c
     
     
      43
     
    
    • 
    
  • 
     
      Objects/floatobject.c
     
     
      38
     
    
    • 
    
  • 
     
      Objects/tupleobject.c
     
     
      37
     
    
    • 
   

   

    The project is open, and help is welcome. Most of CPython is still unmodelled: pick a file whose functions are still marked
    
     todo
    
    in
    
     coverage/methods
    
    , follow
    
     AGENTS.md
    
    , and send a pull request. Independent reviews of existing work count as much as new models. See
    
     CONTRIBUTING.md
    
    .
   

   

    Cite
   

   
@misc{andrews2026formalizing,
  author       = {Andrews, David and Zhang, Chao},
  title        = {Formalizing {CPython}: A Lean Model of {CPython} 3.15.2},
  year         = {2026},
  howpublished = {\url{https://broyojo.com/python-formalization/}},
  note         = {Code: \url{https://github.com/Broyojo/python-formalization}}
}

   

    References
   

   
    
    
  1. 
     M. Cranmer.
     
      Formalizing Julia in Lean (and finding 400+ bugs in Base)
     
     . Julia Discourse, 2026. Code:
     
      MilesCranmer/julia-in-lean
     
     .
    
    2. 
    
  2. 
     L. Koska, T. Koska, B. Koska.
     
      Formalizing PTX in Lean to Prove GPU Kernel Correctness
     
     . arXiv:2611.04447, 2026.
    
    3. 
    
  3. 
     D. Lustig, S. Sahasrabuddhe, O. Giroux.
     
      A Formal Analysis of the NVIDIA PTX Memory Consistency Model
     
     . ASPLOS 2019.
    
    4. 
    
  4. 
     J. G. Politz, A. Martinez, M. Milano, S. Warren, D. Patterson, J. Li, A. Chitipothu, S. Krishnamurthi.
     
      Python: The Full Monty. A Tested Semantics for the Python Programming Language
     
     . OOPSLA 2013.
    
    5. 
    
  5. 
     D. Guth.
     
      A Formal Semantics of Python 3.3
     
     . M.S. thesis, University of Illinois at Urbana-Champaign, 2013. Code:
     
      runtimeverification/python-semantics
     
     .
    
    6. 
    
  6. 
     M. Bodin, A. Charguéraud, D. Filaretti, P. Gardner, S. Maffeis, D. Naudziuniene, A. Schmitt, G. Smith.
     
      A Trusted Mechanised JavaScript Specification
     
     . POPL 2014.
    
    7. 
    
  7. 
     D. Park, A. Ştefănescu, G. Roşu.
     
      KJS: A Complete Formal Semantics of JavaScript
     
     . PLDI 2015.
    
    8. 
    
  8. 
     C. Watt.
     
      Mechanising and Verifying the WebAssembly Specification
     
     . CPP 2018.
    
    9. 
    
  9. 
     X. Leroy.
     
      Formal Verification of a Realistic Compiler
     
     . Communications of the ACM 52(7), 2009.
    
    10. 
    
  10. 
     G. Klein, K. Elphinstone, G. Heiser, J. Andronick, et al.
     
      seL4: Formal Verification of an OS Kernel
     
     . SOSP 2009.
    
    11. 
    
  11. 
     W. M. McKeeman. Differential Testing for Software. Digital Technical Journal 10(1):100–107, 1998.
    
    12. 
    
  12. 
     X. Yang, Y. Chen, E. Eide, J. Regehr.
     
      Finding and Understanding Bugs in C Compilers
     
     . PLDI 2011.
    
    13. 
   

  

 




        

      

    
    

        

          
This Week in People’s History, Nov 11–17, 2026

        

        

          Portside
        

	

	  portside.org
	

        

          2026-11-09 20:45:03
        

        

          
          

            This Week in People’s History, Nov 11–17, 2026

Jonathan Bennett

Mon, 11/09/2026 - 20:45

...
          

        

        

          
Original Article

          

 

  

   
    
     Ham-Handed Police Action with Overtones of Religious Intolerance Helps Turn a Little-Known Cause into a Mainstream Political and Civil Liberties Issue
    
   
  

  

   
    ONE HUNDRED AND FIVE YEARS YEARS AGO, ON NOVEMBER 13, 1921
   
   , a squad of New York City police inadvertently created two storms blowing in opposite directions – one was a windfall of excellent publicity for legalized access to information about birth control, and the other was a storm of very bad publicity for the NYPD.
  

  

   The result was six months worth of major news stories about the brand-new American Birth Control League, which generated a tsunami of political and financial support leading to the League’s incorporation “to conduct a campaign of education for the purpose of repealing, by lawful means, existing State and Federal statutes hostile to information and access to birth control.”
  

  

   In a very short time a movement that had been envisioned by radical feminist Margaret Sanger went from being extremely controversial to being widely supported. Two decades later, the League changed its name to Planned Parenthood.
  

  

   November 13, 1921, was the third and last day of the Manhattan conference where the League was founded. An event that had for two days received a minimum of public attention was suddenly front-page news because the police, without warning, decided to prevent the day’s meeting from starting and, when Sanger and another of the meeting’s leaders refused, arrest them for disorderly conduct.
  

  

   When the police forcibly removed Sanger and Mary Winsor, a member of the League’s National Council, from the stage of Town Hall in Manhattan’s Times Square, a mob scene unfolded, as more than a thousand conference goers were herded out of the building onto West 43rd Street. As Sanger later said, getting arrested unexpectedly for attempting to preside over a peaceful meeting was “unpleasant, to say the least,” but it also uncovered a mother lode of better publicity than money could buy.
  

  

   Two days after the arrests took place, almost all of New York City’s many newspapers played up the story that the “raid” had been ordered by New York’s Catholic Archbishop. The report that the police had acted at the Archbishop’s behest made it impossible for the Mayor to avoid ordering an investigation.
  

  

   Hardly had the mayoral investigation begun than a judge dismissed the disorderly conduct charges against Sanger and Winsor “for a complete lack of evidence.”
  

  

   But the dismissal of the charges didn’t answer the more important question of what had motivated the police, so the investigation continued. In the attempt to get to the bottom of that, investigators required the testimony of one of the League’s wealthy and socially prominent supporters, Juliet Rublee, who was married to Washington lawyer and presidential advisor George Rublee.
  

  

   On December 2, Juliet Rublee, who was a close friend and financial supporter of Sanger, testified about the section of New York’s penal code concerning the dissemination of obscene material or information, which the police claimed to have been enforcing when they padlocked Town Hall. When she finished quoting the law and saying that she disagreed with it, police in the room immediately arrested her for violating the law she had just criticized. The result was another mob scene receiving front-page coverage.
  

  

   Several days later the charge against Rublee was dismissed for lack of evidence. After two months of obfuscatory hemming and hawing by the police, they admitted that all three of the arrests ought not to have occurred. The Archbishop’s role in the affair, or lack of it, was never explicated.
  

  

   Three months later, when the American Birth Control League acquired the status of a New York State corporation, it was well on its way to being the leading organization advocating for the reproductive rights of women in the U.S.
   
    https://sanger.hosting.nyu.edu/articles/town_hall_raid/
   
  

  

   
    For more People’s History, visit
   
   

   
    
     https://www.facebook.com/jonathan.bennett.7771
    
   
   

  

 




        

      

    
    

        

          
Trump backs embattled Hegseth and Jensen Huang and says FBI looking into spy allegations – video

        

        

          Guardian
        

	

	  www.theguardian.com
	

        

          2026-11-09 20:40:32
        

        

          
          

            Donald Trump defended defense secretary Pete Hegseth, who is facing an impeachment resolution from Republican senator Thomas Massie, saying Hegseth 'won two wars'.  The president, who said he had spoken to Nvidia CEO Jensen Huang, said he was 'amazed' by claims Huang conducted an affair with an alle...
          

        

        

          
Original Article

          

 

  

   Donald Trump defended defense secretary Pete Hegseth, who is facing an impeachment resolution from Republican senator Thomas Massie, saying Hegseth 'won two wars'. The president, who said he had spoken to Nvidia CEO Jensen Huang, said he was 'amazed' by claims Huang conducted an affair with an alleged Chinese spy, and that the FBI was now looking into the issue
  

  
 




        

      

    
    

        

          
Qantas to cut 850 Australian jobs and outsource work to India under AI-driven overhaul

        

        

          Guardian
        

	

	  www.theguardian.com
	

        

          2026-11-09 20:34:47
        

        

          
          

            Australian carrier announces agreement with Accenture amid ‘unprecedented’ technological disruption, CEO Vanessa Hudson saysGet our breaking news email, free app or daily news podcastQantas is preparing to cut 850 local jobs and outsource work offshore under an AI-driven overhaul, marking a growing ...
          

        

        

          
Original Article

          

 

  

   Qantas is preparing to cut 850 local jobs and outsource work offshore under an AI-driven overhaul, marking a growing wave of disruption to the Australian workforce.
  

  

   The changes represent the third major corporate layoff plan announced in Australia in three weeks, after restructuring moves flagged by the
   
    design company Canva
   
   and
   
    National Australia Bank
   
   .
  

  

   Qantas said on Tuesday it had signed a multi-year agreement with the professional services firm Accenture to “modernise its back-end systems, processes and data, as it steps up investment in technology and AI”.
  

  

   Some of the services will be transferred to Accenture’s large India-based team.
  

  

   The Qantas chief executive, Vanessa Hudson, said the airline would consult with affected staff and unions before final decisions were made, with the first changes to take effect by midway through next year.
  

  

   “The scale and speed of change in this space is unprecedented and unlike anything businesses have seen in generations,” Hudson said.
  

  

   
    
     Sign up for the Breaking News Australia email
    
   
  

  

   “We know this will be difficult news for some of our people and this decision is not a reflection of their contribution or commitment.”
  

  

   The initial cuts will target finance, procurement, human resources and marketing staff. Qantas has about 32,000 employees, according to its most recent annual report.
  

  

   The changes have drawn a strong response from unions that have previously battled Qantas over
   
    controversial outsourcing decisions
   
   .
  

  

   
    
     skip past newsletter promotion
    
    
   
  

  

   
   
  

  

   The Australian Services Union said Qantas needed to explain itself after earlier promising it had no plans to move any jobs offshore.
  

  

   “AI is having a huge impact on workers across the country, but the cost of technology change should not be borne by the workers who have kept the airline running for years,” assistant national secretary Scott Cowen said.
  

  

   “Sending more jobs overseas is not in the spirit of Australia.”
  

  

   The restructuring comes at a difficult time for Australian workers, with living costs surging and the unemployment rate reaching its
   
    highest level in nearly five years
   
   .
  

  

   A subdued economy, made worse by elevated oil prices stemming from the Iran conflict, is also prompting companies to cut costs.
  

  

   Across just three companies – NAB with 2,500 roles, Canva with 1,200, and now Qantas with 850 – about 4,550 corporate jobs have been targeted for cuts, relocations or restructuring in the past month.
  

  

   While Qantas has been grappling with rising jet fuel prices, the costs have been partially offset by ticket sales to new customers who switched to the airline after cancelling flights at those with Middle East stopovers.
  

  

   Qantas said in a market update late last week that while customer demand was proving resilient, it would continue to adjust fares and capacity in response to fuel costs.
  

 




        

      

    
    

        

          
Teenager who planned terror attack in Sydney tells court he was radicalised online and used AI to strategise

        

        

          Guardian
        

	

	  www.theguardian.com
	

        

          2026-11-09 20:09:19
        

        

          
          

            Boy says he was first exposed to extremist material on TikTok, turned to Telegram and YouTube for bomb-making instructions, and used ChatGPT to devise his plansGet our breaking news email, free app or daily news podcastA teenager who admitted to planning a terrorist attack in Sydney in 2024 has told...
          

        

        

          
Original Article

          

 

  

   A teenager who admitted to planning a terrorist attack in Sydney in 2024 has told the court he was radicalised online after first seeing extremist material on TikTok and used
   
    ChatGPT
   
   to form his plans.
  

  

   The 16-year-old, known under the pseudonym as RK due to his age, pleaded guilty to acts in preparation for, or planning, a terrorist act. In a sentencing ruling on Monday, he avoided jail time, with the
   
    New South Wales
   
   supreme court ordering him into a three-year community corrections order.
  

  

   RK had just turned 14 when the offending occurred in 2024. He told the court he was first exposed to extremist material on
   
    TikTok
   
   .
  

  

   “Initially, he was looking at historical content that may have had a political theme. He saw videos about the crusaders and ‘their empires’,” Justice Stephen Campbell said in the decision.
  

  

   “He progressed to videos about the events of September 11, 2001 and the resulting war on terror (and the wars after that).”
  

  

   
    
     Sign up for the Breaking News Australia email
    
   
  

  

   Campbell said RK then progressed to watching religious-themed videos, which “led him to other content of increasing violence” and then talking about these subjects with people on the internet.
  

  

   RK told the court he was trying to impress these people, and became focused on the
   
    Sydney Opera House
   
   as a potential location for an act of violence. He said he had become radicalised and “brainwashed by propaganda” when he began looking at bomb-making videos on YouTube, but Campbell said he had no concrete plans for committing a terrorist act, and had not obtained any material for bomb-making.
  

  

   RK used
   
    Telegram
   
   , seeking instructions on making a pressure cooker bomb, and attempted to contact the surviving Boston marathon bomber, Dzhokhar Tsarnaev, by email.
  

  

   The teenager used ChatGPT to obtain information about the bomber, and asked the AI chatbot if inmates had access to news.
  

  

   “Exhibiting what appears to me to be a complete lack of understanding of the import of his conduct, the young person emailed the prison, using a publicly available email address, asking whether he could email Tsarnaev,” Campbell said in his judgment, adding RK never ultimately made contact with the bomber.
  

  

   RK asked ChatGPT about security arrangements at the Sydney Opera House, where the Sydney marathon finishes, and where terrorists were imprisoned in NSW. He watched videos about the Sydney Opera House on
   
    YouTube
   
   , and researched gay nightclubs and other places where “infidels” gather.
  

  

   
    
     skip past newsletter promotion
    
    
   
  

  

   
   
  

  

   On Telegram, RK sent Islamic State videos to others to “seek validation” because he thought it was “cool”, Campbell said.
  

  

   OpenAI, Telegram and YouTube were approached for comment. TikTok declined to comment.
  

  

   The teenager has since expressed remorse for his actions, and Campbell said he had underwent six sessions of religious and ethical training from a Muslim cleric.
  

  

   “I am satisfied that he has genuinely renounced his adherence to Islamic violent extremism, which in any event was incipient and hesitant during the short period of his offending,” Campbell said. “I fully accept he was radicalised to a degree, but that the process of deradicalisation is well advanced.”
  

  

   The Asio deputy director general for intelligence service delivery, Claire McGuinness,
   
    told a parliamentary inquiry last month
   
   that detecting and disrupting online youth radicalisation had become very challenging for the security agency.
  

  

   “It usually begins quietly. A young person is scrolling through Instagram or TikTok or a similar platform,” she said. “They encounter something that catches their attention, perhaps a political meme or a religiously conservative video.
  

  

   “At first it isn’t terrorism – it’s just fringe; it is extremist-adjacent. But, the moment they engage, the algorithm takes over and so the feed tightens, the content shifts from conservative to radical, and from radical to security-relevant.”
  

  

   From there, teenagers often move to platforms such as Discord or Telegram where “dark humour and the edgy memes” groom teens to accept progressively more extreme content, McGuinness said, before passive consumption turns to active engagement in researching methods.
  

 




        

      

    
    

        

          
Blunt Banhammer Blocks Basic Bots Ballistically

        

        

          Lobsters
        

	

	  shkspr.mobi
	

        

          2026-11-09 19:48:20
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   I cut bot traffic to my site by over 80% with a simple trap.
  

  

   Last month, my hobby website
   
    OpenBenches.org
   
   transferred more than 2.5TB of data to visitors. As much as I'd like to think the site is enormously popular, it looks like it is just AI bots endlessly crawling the data and slurping up the images.
  

  

   So I've built B
   
    6
   
   to be an indiscriminate tool to eradicate these unwanted parasites.
  

  

   It is
   
    very
   
   loosely inspired by
   
    Jeff Starr's Blackhole
   
   , but works even on sites with heavy caching.
  

  

   Here's the high level description of how it works.
  

  
    
   
  • 
    Create a directory like
    
     /honeypot/
    
    on your site
   
    • 
   
  • 
    Put some code in
    
     index.php
    
    within the directory
   
    • 
   
  • 
    Add the honeypot as an explicit "Disallow" in
    
     robots.txt
    
   
    • 
   
  • 
    Include a hidden link to to the honeypot on every page of your site
   
    • 
   
  • 
    If something accesses that page, write its IP address to your
    
     .htaccess
    
   
    • 
   
  • 
    The
    
     .htaccess
    
    bans the IP address from ever accessing your site again.
   
    • 
  

  

   This blog post shows you how you can build this yourself and discusses some of the problems it might cause.
  

  

   
    Bad Robots!
   
  

  

   The file
   
    robots.txt
   
   lives at the root of your website. It contains a list of instructions to automated web crawlers. Respectful bots will read it and refuse to look at specific parts of your site.
  

  

   Add these two lines to it:
  

  
   Copied  to 📋
  
  
 User-agent: *
Disallow: /honeypot/


  

   That says bots shouldn't visit any page in the honeypot directory.
  

  

   Bots generally check for updates every 24 hours, so either wait a day or manually submit it to major crawlers.
  

  

   
    .htaccess
   
  

  

   The
   
    .htaccess file
   
   contains a list of instructions for how your server should process requests.
  

  

   Find the bit of your
   
    .htaccess
   
   file which looks like this:
  

  
   Copied  to 📋
  
  
 <IfModule mod_rewrite.c>
        RewriteEngine On
        RewriteBase /


  

   Edit it to look like this:
  

  
   Copied  to 📋
  
  
 <IfModule mod_rewrite.c>
        RewriteEngine On
        RewriteBase /

### BLOCKED IPs
    #   TEST-NET-1
    RewriteCond %{REMOTE_ADDR} "=192.0.2.1"
    RewriteRule ^ - [R=402,L]
### /BLOCKED IPs


  

   It is important that these rules come before any other rewrite rules.
  

  

   Change the end of this
   
    IfModule
   
   to look like:
  

  
   Copied  to 📋
  
  
 </IfModule>

ErrorDocument 402 "Payment Required - Access Denied."


  

   If an IP address is in the blocked IP list, the server will send an error code and a readable message. You can add whatever plain text you like here.
  

  

   
    Wipe Them All Out
   
  

  

   Inside the honeypot directory, create a file called
   
    index.php
   
   (or whatever you like). When this page is visited, it grabs the visitor's IP address and the name of its User Agent. It then places them in the BLOCKED IPs section.
  

  
   Copied PHP to 📋
  
  
 PHP//  What's their IP?
$IP = get_client_ip();

//  User Agent
$UA = isset( $_SERVER["HTTP_USER_AGENT"] ) ? $_SERVER["HTTP_USER_AGENT"] : "";

//  Get the existing .htaccess file.
$htaccess_file = "../.htaccess";
$htaccess = file_get_contents( $htaccess_file );

//  Split by newline.
$htaccess_lines = explode( separator: "\n", string: $htaccess );

//  Where's our start block?
$start = "###   BLOCKED IPs";
$end   = "###   /BLOCKED IPs";

//  Exit if the .htaccess doesn't have the block.
if ( !in_array( needle: $start, haystack: $htaccess_lines ) ) { die(); }

//  This is where to start from.
$start_block = array_search( needle: $start, haystack: $htaccess_lines );

//  Add the line after the start block.
//  Include a date.
$htaccess_lines[ $start_block ] = $start . "\n" . 
    "\t#\t" . date( "c" ) . "\t{$UA}\n" . 
    "\tRewriteCond %{REMOTE_ADDR} \"={$IP}\" [OR]";

//  Turn the array back to a string.
$newHtaccess = implode( separator: "\n", array: $htaccess_lines );

//  Save the new .htaccess file.
file_put_contents( filename: $htaccess_file, data: $newHtaccess );

function get_client_ip():string
{
    //  Adapted from https://github.com/ibericode/koko-analytics/blob/main/src/Resources/functions/collect.php

    //  X-Forwarded-For sometimes contains a comma-separated list of IP addresses
    //  @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For
    $ips = empty( $_SERVER["HTTP_X_FORWARDED_FOR"] ) ?
        [] :
        \array_map( "trim", \explode( ",", $_SERVER["HTTP_X_FORWARDED_FOR"] ) );

    //  Always add REMOTE_ADDR and HTTP_CLIENT_IP to list of ip addresses, if set
    foreach ( ["REMOTE_ADDR", "HTTP_CLIENT_IP"] as $key ) {
        if ( !empty( $_SERVER[$key] ) ) {
            $ips[] = $_SERVER[$key];
        }
    }

    //  Return first valid IP address from list
    foreach ( $ips as $ip ) {
        if ( \filter_var( $ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE ) ) {
            return $ip;
        }
    }

    return "";
}


  

   
    Setting The Trap
   
  

  

   Web crawlers look at a page, find every link on it, then visit those links. So we need to put a link to the honeypot on every page - but in such a way that normal users will not find it or click it.
  

  

   This adds a link, removes it from the accessibility tree, and gives it impossible to click text (a zero width joiner).
  

  
   Copied HTML to 📋
  
  
 HTML<a id="honey" aria-hidden="true" href="/honeypot/index.php">‍</a>


  

   This CSS hides it from normal viewers and removes the mouse cursor from view.
  

  
   Copied CSS to 📋
  
  
 CSS#honey {
    display: none !important;
    cursor:  none !important;
}


  

   
    Problems This Might Cause
   
  

  

   It's unlikely that a human will find the link, click on it, and be banned. But if they do, consider put a message in the blocking text telling them how they can get unblocked.
  

  

   Some useful bots ignore robots.txt. If they identify themselves via a User-Agent string (and they should) you can manually remove them from .htaccess. You could also code in an allow list exemption for them. But, of course, many bad bots lie about who they really are.
  

  

   Conversely, not all bots crawl every link. This won't catch bots which respect robots.txt but are nevertheless problematic.
  

  

   If you have thousands of different bots blocked, the performance of your server
   
    might
   
   slow down while .htaccess is parsed. There's weak anecdotal evidence that it adds a slight overhead. But, personally, I don't think that's worth worrying about.
  

  

   Bots often use hijacked IP addresses. After the bot has moved, an innocent party might be blocked from your site. Each block has a timestamp associated with it. You could periodically unblock older entries.
  

  

   Bots rotate through hundreds of different IP addresses. So the same bot might get blocked multiple times.
  

  

   Bots might see the CSS marks the link as hidden and refuse to follow it. Instead of CSS, you could use invisible spaces or other characters which would be hard for a human to see but appear visible to a bot.
  

  

   Similarly, a smart bot might refuse to visit a path called /honeypot/ so choose a better name for it. A smarter bot would see that touching the honeypot leads to a ban - so perhaps a selection of traps are needed?
  

  

   As is implied in the name, this is a
   
    blunt
   
   banhammer. It doesn't give a warning, nor does it look at User-Agent, Country, or any other signal. You touch the honeypot and you receive an instaban. No warning and no automated way to appeal.
  

  

   
    Alternatives
   
  

  

   There are alternative ways to do this. Some bots don't send language headers, some use older versions of HTTP, they often have severely outdated User Agent strings. Those are all reasonable ways to block something which is
   
    probably
   
   a bot. There are likely to be a few false positives though.
  

  

   But B
   
    6
   
   has no false positives. A normal user
   
    can't
   
   follow the link to the trap and a well-behaved bot
   
    won't
   
   follow the link.
  

  

   Things like Anubis require a lot of work to set up and annoy normal users. B
   
    6
   
   doesn't require a specific hosting environment and is never shown to normal users.
  

  

   
    It Works!
   
  

  

   Since running B
   
    6
   
   a week ago, I've blocked over 400 IP addresses and seen a significant fall in traffic. I've not had any complaints yet. Sadly, none of the bots have paid to remove the paywall!
  

  

   Drop from 216GB to 26GB per day.
  

  

   At peak, my site was seeing 216GB of data transfer per day. That's now dropped to around 25GB.
  

  

   I don't claim this is the most sophisticated bot blocker in existence - but I enjoyed building it myself. I'll probably add something to records the geolocation of the IP and maybe remove any block older than a certain age.
  

  

   If you'd like to use it or improve this code, I'd be grateful if you treated it as
   
    AGPL v3 licensed
   
   .
  

 




        

      

    
    

        

          
The Open and Shut Impeachment Case Against Tod Blanche

        

        

          Portside
        

	

	  portside.org
	

        

          2026-11-09 19:47:46
        

        

          
          

            The Open and Shut Impeachment Case Against Tod Blanche

barry

Mon, 11/09/2026 - 19:47

...
          

        

        

          
Original Article

          

 

  

   
    On Saturday, Donald Trump
   
   
    
     ordered
    
   
   
    the Justice Department to investigate members of Congress for the offense of proposing to impeach his attorney general. He branded the talk “extortion at the highest level” and announced, “I am ordering the Department of Justice to look into this criminal act, immediately!”
   
  

  

   We can expect the department to fall into line dutifully, because Attorney General Todd Blanche has already demonstrated his eagerness to convert federal prosecution into a weapon against the president’s enemies, wielded without regard to the facts, the law, or the commission of any crime. He said as much yet again Sunday in an
   
    
     interview
    
   
   with CNN’s Dana Bash that should be played back to him at an impeachment proceeding.
  

  

   That practice stands atop the list of Trump 2.0’s manifold abuses of democracy and departures from constitutionalism and the rule of law. It follows that Blanche stands atop the list of Trump officials whom the incoming Democrats must aim to remove from office.
  

  

   It is high time to impeach Todd Blanche.
  

  

   With the House gavel in January comes a choice of priorities. This administration has repeatedly subverted the constitutional structure of checks and balances; bungled foreign policy, including through illegal misadventures, in ways that have profoundly undermined the national interest; and enriched the president and his allies at public expense.
  

  

   These grievous offenses—all departures from the essential Article 2 command that the president “take Care that the Laws be faithfully executed”—require staunch investigation, oversight, and remedy. But the first order of business is to reaffirm the rule of law and democracy, and to strike back against the most virulent attacks on them.
  

  

   The essential distinction that should lead Representative Jamie Raskin, the incoming House Judiciary Committee chair, and the committee’s new majority to vote on articles of impeachment against Blanche is between abuses of executive power on the one hand and the embrace of authoritarianism and the negation of the constitutional rule of law on the other.
  

  

   For the last 20 months, the Justice Department hasn’t been flirting with authoritarianism. It has been an anti-Democratic stronghold, embracing practices that don’t happen in a democracy, and that in fact define authoritarian rule.
  

  

   Democratic Representative Hank Johnson of Georgia has stated the umbrella case for impeaching and removing Blanche. The menu of possible articles runs long: illegal firings, including Maurene Comey’s, as a federal judge
   
    
     ruled
    
   
   last week; an early push, with his deputy Emil Bove—now, incredibly, a federal appellate judge—to ship immigrants out of the country whether or not the law allowed it; a sit-down with Ghislaine Maxwell not long before she landed in a minimum security camp.
  

  

   Yet if I were drafting the articles, I’d opt to set aside, for the time being, all those horrendous abuses in the sycophantic service of Donald Trump and advance a single count: that Blanche has wielded the power of federal prosecution to punish the president’s enemies.
  

  

   As Vladimir Putin’s persecution of Alexei Navalny shows, a single instance tells you everything about a regime, and a single instance would justify impeachment and removal. With Blanche, we have a long and growing list: Jim Comey, three times over. Letitia James. Cassidy Hutchinson. Six Democratic lawmakers, for making a video about illegal orders.
  

  

   A one-count article of impeachment reduces the overall firepower of the case against Blanche, but it trains Congress’s and the nation’s focus on reprisal prosecutions, the Trump 2.0 practice that is the singular paradigm of authoritarianism. Three reasons make the reprisal count the right one.
  

  

   First, reprisal prosecutions don’t merely abuse power; they violate the Constitution in and of themselves. The Supreme Court has called punishing someone for doing what the law allows “a due process violation of the most basic sort.” When the charges are brought in retaliation for protected speech, as with Comey or the six Democratic lawmakers, the prosecution violates the First Amendment as well.
  

  

   Second, reprisal prosecutions are designed to cow dissent more broadly. Blanche’s prominent targets—a former FBI director, a witness who testified to Congress, lawmakers who reminded troops of their duty—cast a broad shadow over other political critics. Along with intimidating political adversaries, that is the point. Each case warns every potential critic, witness, and whistleblower to keep quiet or face criminal prosecution. And because a reprisal prosecution does its damage before any judge rules, and prosecutors enjoy absolute immunity from damages, the courts can’t undo it. Impeachment is the one remedy that reaches the official responsible.
  

  

   Third, and most important, prosecuting the leader’s enemies on manufactured or nonexistent charges is the bright line between democracy and autocracy. It’s the unmistakable mark of authoritarianism.
  

  

   Compare Blanche with Defense Secretary Pete Hegseth, whose impeachment GOP Representative Thomas Massie may force to a vote as early as this week. Massie’s eight articles charge Hegseth with waging war in Iran in defiance of the War Powers Resolution, with a strike that killed more than 150 people at a girls’ school in Minab, and with boat strikes in our hemisphere that have killed at least 221 people without a shred of process.
  

  

   It’s an odious list that advances a strong case for impeachment. But it consists largely of abuses of democratic rule, not negation of it. Democracies aren’t immune from transgressing the law of war, and there is by now an extended history of military engagements that Congress never authorized. The core case against Hegseth is that he’s a flaming asshole—a terrible, arrogant secretary of defense whose tenure has sharply undermined the national interest.
  

  

   The exception proves the rule. Massie’s sixth article charges Hegseth with threatening Senator Mark Kelly with prosecution for telling service members they may refuse illegal orders. Of the eight counts, it’s the only one that smells of Moscow. And Blanche’s Justice Department took the next step: It tried to indict Kelly and five colleagues over that same video.
  

  

   Now picture a Senate trial of Blanche on a single count of reprisal prosecutions. The charge is clean. There’s no obscuring or evading it.
  

  

   What might Blanche possibly say in his own defense? That he never undertook reprisal prosecutions? Fat chance: He not only saluted and discharged the orders; he defended them publicly as a legitimate exercise of Trump’s Article II powers.
  

  

   That Trump told him to? That’s the defense Lt. William Calley offered for My Lai during the Vietnam era, and the military courts rejected it: An order to do something plainly unlawful binds no one. Sorry, but Blanche isn’t a 24-year-old lieutenant in a jungle. He’s the attorney general, who swore to support and defend the Constitution, not to blindly obey the president.
  

  

   That he did it, but it was Trump’s right to order it? Blanche has tried that one before. He famously declined to pledge independence from the White House, saying “no attorney general should ever pledge that.”
  

  

   In fact, no attorney general should ever pledge to follow a president blindly into the dark corner of reprisal prosecutions. To acquit Blanche on that ground, the Senate would have to ratify the authoritarian detour he engineered.
  

  

   The American system has absorbed many abuses of power and strains on the rule of law under Trump 2.0. The criminal prosecution of innocent people because they are the president’s political enemies is something else: Not a strain, but a break. Justice without fear or favor, the department’s own maxim, is no mere aspiration. It is the sine qua non of the rule of law. The new Congress’s first responsibility should be to reject Blanche’s crass and corrupt embrace of the rule of tyrants.
  

 

 

  

   

    
    
    
     is a senior legal columnist at The New Republic, a senior fellow at the USC Center on Communication Leadership and Policy, and the creator of
    
    
     
      
       Talking Feds
      
     
    
    
     , a Substack and podcast on legal and political issues. A lawyer, professor, and legal commentator, he is the former U.S. attorney for the Western District of Pennsylvania and has served as a deputy assistant attorney general at the Department of Justice. He clerked for Supreme Court Justices Thurgood Marshall and Anthony Kennedy, and has taught at UCLA School of Law and UC San Diego. He is also a former legal affairs columnist at the Los Angeles Times.
    
   

  

  

   
    
     
      The New Republic
     
    
   
   
    
     was founded in 1914 to bring liberalism into the modern era. The founders understood that the challenges facing a nation transformed by the Industrial Revolution and mass immigration required bold new thinking.
    
   
  

  

   
    
     Today’s New Republic is wrestling with the same fundamental questions: how to build a more inclusive and democratic civil society, and how to fight for a fairer political economy in an age of rampaging inequality. We also face challenges that belong entirely to this age, from the climate crisis to Republicans hell-bent on subverting democratic governance.
    
   
  

  

   
    
     We’re determined to continue building on our founding mission.
    
   
  

  

   
    
     
      Sign up
     
    
   
   
    
     for a TNR newsletter on politics, climate, culture and more.
    
   
   

  

 




        

      

    
    

        

          
The Open and Shut Impeachment Case Against Todd Blanche

        

        

          Portside
        

	

	  portside.org
	

        

          2026-11-09 19:47:46
        

        

          
          

            The Open and Shut Impeachment Case Against Todd Blanche

barry

Mon, 11/09/2026 - 19:47

...
          

        

        

          
Original Article

          

 

  

   
    On Saturday, Donald Trump
   
   
    
     ordered
    
   
   
    the Justice Department to investigate members of Congress for the offense of proposing to impeach his attorney general. He branded the talk “extortion at the highest level” and announced, “I am ordering the Department of Justice to look into this criminal act, immediately!”
   
  

  

   We can expect the department to fall into line dutifully, because Attorney General Todd Blanche has already demonstrated his eagerness to convert federal prosecution into a weapon against the president’s enemies, wielded without regard to the facts, the law, or the commission of any crime. He said as much yet again Sunday in an
   
    
     interview
    
   
   with CNN’s Dana Bash that should be played back to him at an impeachment proceeding.
  

  

   That practice stands atop the list of Trump 2.0’s manifold abuses of democracy and departures from constitutionalism and the rule of law. It follows that Blanche stands atop the list of Trump officials whom the incoming Democrats must aim to remove from office.
  

  

   It is high time to impeach Todd Blanche.
  

  

   With the House gavel in January comes a choice of priorities. This administration has repeatedly subverted the constitutional structure of checks and balances; bungled foreign policy, including through illegal misadventures, in ways that have profoundly undermined the national interest; and enriched the president and his allies at public expense.
  

  

   These grievous offenses—all departures from the essential Article 2 command that the president “take Care that the Laws be faithfully executed”—require staunch investigation, oversight, and remedy. But the first order of business is to reaffirm the rule of law and democracy, and to strike back against the most virulent attacks on them.
  

  

   The essential distinction that should lead Representative Jamie Raskin, the incoming House Judiciary Committee chair, and the committee’s new majority to vote on articles of impeachment against Blanche is between abuses of executive power on the one hand and the embrace of authoritarianism and the negation of the constitutional rule of law on the other.
  

  

   For the last 20 months, the Justice Department hasn’t been flirting with authoritarianism. It has been an anti-Democratic stronghold, embracing practices that don’t happen in a democracy, and that in fact define authoritarian rule.
  

  

   Democratic Representative Hank Johnson of Georgia has stated the umbrella case for impeaching and removing Blanche. The menu of possible articles runs long: illegal firings, including Maurene Comey’s, as a federal judge
   
    
     ruled
    
   
   last week; an early push, with his deputy Emil Bove—now, incredibly, a federal appellate judge—to ship immigrants out of the country whether or not the law allowed it; a sit-down with Ghislaine Maxwell not long before she landed in a minimum security camp.
  

  

   Yet if I were drafting the articles, I’d opt to set aside, for the time being, all those horrendous abuses in the sycophantic service of Donald Trump and advance a single count: that Blanche has wielded the power of federal prosecution to punish the president’s enemies.
  

  

   As Vladimir Putin’s persecution of Alexei Navalny shows, a single instance tells you everything about a regime, and a single instance would justify impeachment and removal. With Blanche, we have a long and growing list: Jim Comey, three times over. Letitia James. Cassidy Hutchinson. Six Democratic lawmakers, for making a video about illegal orders.
  

  

   A one-count article of impeachment reduces the overall firepower of the case against Blanche, but it trains Congress’s and the nation’s focus on reprisal prosecutions, the Trump 2.0 practice that is the singular paradigm of authoritarianism. Three reasons make the reprisal count the right one.
  

  

   First, reprisal prosecutions don’t merely abuse power; they violate the Constitution in and of themselves. The Supreme Court has called punishing someone for doing what the law allows “a due process violation of the most basic sort.” When the charges are brought in retaliation for protected speech, as with Comey or the six Democratic lawmakers, the prosecution violates the First Amendment as well.
  

  

   Second, reprisal prosecutions are designed to cow dissent more broadly. Blanche’s prominent targets—a former FBI director, a witness who testified to Congress, lawmakers who reminded troops of their duty—cast a broad shadow over other political critics. Along with intimidating political adversaries, that is the point. Each case warns every potential critic, witness, and whistleblower to keep quiet or face criminal prosecution. And because a reprisal prosecution does its damage before any judge rules, and prosecutors enjoy absolute immunity from damages, the courts can’t undo it. Impeachment is the one remedy that reaches the official responsible.
  

  

   Third, and most important, prosecuting the leader’s enemies on manufactured or nonexistent charges is the bright line between democracy and autocracy. It’s the unmistakable mark of authoritarianism.
  

  

   Compare Blanche with Defense Secretary Pete Hegseth, whose impeachment GOP Representative Thomas Massie may force to a vote as early as this week. Massie’s eight articles charge Hegseth with waging war in Iran in defiance of the War Powers Resolution, with a strike that killed more than 150 people at a girls’ school in Minab, and with boat strikes in our hemisphere that have killed at least 221 people without a shred of process.
  

  

   It’s an odious list that advances a strong case for impeachment. But it consists largely of abuses of democratic rule, not negation of it. Democracies aren’t immune from transgressing the law of war, and there is by now an extended history of military engagements that Congress never authorized. The core case against Hegseth is that he’s a flaming asshole—a terrible, arrogant secretary of defense whose tenure has sharply undermined the national interest.
  

  

   The exception proves the rule. Massie’s sixth article charges Hegseth with threatening Senator Mark Kelly with prosecution for telling service members they may refuse illegal orders. Of the eight counts, it’s the only one that smells of Moscow. And Blanche’s Justice Department took the next step: It tried to indict Kelly and five colleagues over that same video.
  

  

   Now picture a Senate trial of Blanche on a single count of reprisal prosecutions. The charge is clean. There’s no obscuring or evading it.
  

  

   What might Blanche possibly say in his own defense? That he never undertook reprisal prosecutions? Fat chance: He not only saluted and discharged the orders; he defended them publicly as a legitimate exercise of Trump’s Article II powers.
  

  

   That Trump told him to? That’s the defense Lt. William Calley offered for My Lai during the Vietnam era, and the military courts rejected it: An order to do something plainly unlawful binds no one. Sorry, but Blanche isn’t a 24-year-old lieutenant in a jungle. He’s the attorney general, who swore to support and defend the Constitution, not to blindly obey the president.
  

  

   That he did it, but it was Trump’s right to order it? Blanche has tried that one before. He famously declined to pledge independence from the White House, saying “no attorney general should ever pledge that.”
  

  

   In fact, no attorney general should ever pledge to follow a president blindly into the dark corner of reprisal prosecutions. To acquit Blanche on that ground, the Senate would have to ratify the authoritarian detour he engineered.
  

  

   The American system has absorbed many abuses of power and strains on the rule of law under Trump 2.0. The criminal prosecution of innocent people because they are the president’s political enemies is something else: Not a strain, but a break. Justice without fear or favor, the department’s own maxim, is no mere aspiration. It is the sine qua non of the rule of law. The new Congress’s first responsibility should be to reject Blanche’s crass and corrupt embrace of the rule of tyrants.
  

 

 

  

   

    
    
    
     is a senior legal columnist at The New Republic, a senior fellow at the USC Center on Communication Leadership and Policy, and the creator of
    
    
     
      
       Talking Feds
      
     
    
    
     , a Substack and podcast on legal and political issues. A lawyer, professor, and legal commentator, he is the former U.S. attorney for the Western District of Pennsylvania and has served as a deputy assistant attorney general at the Department of Justice. He clerked for Supreme Court Justices Thurgood Marshall and Anthony Kennedy, and has taught at UCLA School of Law and UC San Diego. He is also a former legal affairs columnist at the Los Angeles Times.
    
   

  

  

   
    
     
      The New Republic
     
    
   
   
    
     was founded in 1914 to bring liberalism into the modern era. The founders understood that the challenges facing a nation transformed by the Industrial Revolution and mass immigration required bold new thinking.
    
   
  

  

   
    
     Today’s New Republic is wrestling with the same fundamental questions: how to build a more inclusive and democratic civil society, and how to fight for a fairer political economy in an age of rampaging inequality. We also face challenges that belong entirely to this age, from the climate crisis to Republicans hell-bent on subverting democratic governance.
    
   
  

  

   
    
     We’re determined to continue building on our founding mission.
    
   
  

  

   
    
     
      Sign up
     
    
   
   
    
     for a TNR newsletter on politics, climate, culture and more.
    
   
   

  

 




        

      

    
    

        

          
Horible public key tricks

        

        

          Hacker News
        

	

	  maurycyz.com
	

        

          2026-11-09 19:07:17
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  
   
  
  —
  
   
  
  
  

   So, I've always been somewhat annoyed at SSL/TLS.
It requires everyone to go through a complex "ACME" dance just to put up a public website.
Worse, certificates expire every few months, so it's not a one and done thing:
even with automation, maintaining a certificate requires care to ensure the ACME client always has access to DNS records or the web server.
  

  

   ... and the whole system doesn't even work because certificates are issued over plaintext connections,
and trusted certificate aurthorities use very secure keys like
   
    "4"
   
   
  

  

   
    There is prior art
   
   of protest SSL
   
    implementations
   
   ,
but I do actually want to encrypt web traffic.
Passive eavesdropping is a real risk... but preventing it doesn't require the whole certificate thing:
therefore, the best choice is a protest certificate.
  

  

   The only part of the certificate I directly control is the public key.
Therefore, the simplest way to obtain a bad certificate is use a vanity private key such as 313333333337 (one of the most eleet primes).
However, while the resulting public key would be weak, no one would know unless they try to break it.
  

  

   A good protest should be obvious:
  

  
# openssl s_client -connect maurycyz.com:443 < /dev/null 2> /dev/null \
    | sed -n /BEGIN/,/END/p | grep -zE '////.?*////' --color=yes

-----BEGIN CERTIFICATE-----
MIIFAjCCA+qgAwIBAgISBkOkuuyaN1ypD3PAPrLMyT7tMA0GCSqGSIb3DQEBCwUA
MDMxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MQwwCgYDVQQD
EwNZUjIwHhcNMjYxMTA5MTcyOTQ2WhcNMjcwMjA3MTcyOTQ1WjAXMRUwEwYDVQQD
EwxtYXVyeWN5ei5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCg
JyPf37Sj6PvU06m5////You+dont+actually+have+to+pick+random+privat
e+keys//No+one+checks+these+things//A+certificate+authority+got+
away+with+the+number+4+for+a+year/////DSfCAfXcsJfBpnHekS0qnf5YLl
c54VuUNRVINcDkEwJDwyB96+xE/uXhtiGdk8ty1PF6jciLEYCJBHcmqOa5pOyV8m
63yR3NE6hCQlaSLQQDo96Sb0/10aC5LqE7KwEskrP/qeCzT7vDN7fh+dXOGs+VMw
eJvTAb0xHJpxhSK05i7DAgMBAAGjggIqMIICJjAOBgNVHQ8BAf8EBAMCBaAwEwYD
VR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQUBKBfDbwf
dCnKeU83pMTWyFrJBwAwHwYDVR0jBBgwFoAUQBUtJnntMiCe35pyHdYyH4EMgQww
MwYIKwYBBQUHAQEEJzAlMCMGCCsGAQUFBzAChhdodHRwOi8veXIyLmkubGVuY3Iu
b3JnLzAnBgNVHREEIDAegg4qLm1hdXJ5Y3l6LmNvbYIMbWF1cnljeXouY29tMBMG
A1UdIAQMMAowCAYGZ4EMAQIBMC8GA1UdHwQoMCYwJKAioCCGHmh0dHA6Ly95cjIu
Yy5sZW5jci5vcmcvMTEwLmNybDCCAQsGCisGAQQB1nkCBAIEgfwEgfkA9wB1AExj
3JjlnB2riPYeij3ero+rRKM3e1+blMP7oZz8wb4mAAABocGRbw4AAAQDAEYwRAIg
HShWaEI2nVJEizSI6sJ/jnLaABZ3aTKoUL3pLo1uOgsCIEn+XiT2WHhm9LGN6kug
O9R7Z4q0HiFA4RZ7tIMJQH5XAH4AjspHC6zeavOiBrCkeoS3Rv4fxr+VPiXmm07k
AkjzxugAAAGhwZFyfQAIAAAFAEE0hdwEAwBHMEUCIDSms4Vf0llcvcldJd2Ool8i
AiUQQlS0Zzbej+7Y1aR7AiEA79Ll+t6inu1PkUIgzNTXkE0S20VHYEYel5fkdKSA
VTQwDQYJKoZIhvcNAQELBQADggEBAFi3A4fcjj4UKa9MFz1a8DWc+Jya2gJng13m
2UFdWCaqsN7FJWQEjRiJ0npynmDnA3VMyjswUMHAMx4d8G3lHNPfZWGsCgpjVa/d
IEoeZ6gTYjFa/Ovb64m4CcuQkm0GxcyAqMPs348e6Px32iU1R6MnV4UEUosnSPeK
4ocuI3SoR9LHxX/yHOKcYTKLpIMwMdaAmWt0N7l59GOb8o+dz3R7cxtVV/lrZReZ
/YPEAYRiNi7f+jNI1JCp0i8wXUb9NN7WlbmcFDecDG/++cRpAkoIk4m/LJindsuu
kErrVZ4yLqB0Hvm+uNvWxr9y/qKFTYw9POx1oaZJO/SwXZdDBeY=
-----END CERTIFICATE-----


  

   
    First, let's look at mathematical framework
   
   of RSA.
To generate a key, pick two large prime numbers (p and q) and multiply them to yeild the modulus (n).
Pick a small number, e as public exponent.
  

  

   The RSA public key is composed of the modulus (n) and the public exponent:
  

  
# Encryption requires knowing e (public)
cyphertext = plaintext^e mod n


  

   The private key contains the modulus and the private exponent (d) which is chosen to be the multiplicate inverse of e modulo n.
Exactly how d is found is not relevent, but the process requires knowing p and q.
  

  
# Decryption requires knowing d (pivate)
= cyphertext^d mod n

= plaintext^e^d mod n
= plaintext^(e*d) mod n
= plaintext^1 mod n
= plaintext


  

   
   
    Ok, back to vanity keys.
   
   The standard value for e is 65537 (0x10001),
because the small number of set bits makes encryption faster.
In fact, the CA I used will refuse to sign keys with a non-standard public exponent, so I can't do anything funny there.
  

  

   The modulus, n, is either 2,048 or 4,096 "user controlled" bits, so it's the ideal place to hide a message.
However, to use the certificate, I'll need to find two large primes that multiply out to the vanity modulus.
  

  

   My method starts by picking two random primes and calculating the resulting n value.
Then, the bytes of n are modified to introduce message into the base64 encoding.
Of course, the modified n is not the product of p and q, but this is fixable by setting q to n/p.
  

  

   The resulting q value is very unlikely to be a prime (or integer), so I round it and find the next prime after the ideal q:
which usually only requires changing the value of q by a few hundred.
Since p and q are similar in size, a small change q only affects the least-sigifiant half of the product:
  

  
58174124 * 918491824 = 53432457262362176
(incrementing until the next prime...)
58174124 * 918491843 = 53432458367670532


  

   As long as the message is embedded into the upper half of n, it's likely to survive undamaged.
The original p and newly selected q can now be used to construct a functional RSA private key in the usual manner.
  

  

   From here, it's really just a matter of getting a certificate aurthority to sign the key:
  

  
# Single domain
openssl req -new -key priv.pem -subj '/C=US/CN=example.com' > cert_request
certbot certonly --manual --csr cert_request

# Wildcard
cat > config<<EOF
[ req ]
req_extensions = req_ext

[ req_ext ]
subjectAltName = @alt_names

[ alt_names ]
DNS.1 = *.example.com
DNS.2 = example.com
EOF
openssl req -new -key priv.pem -config config -subj '/C=US/CN=example.com' > cert_request
certbot certonly --manual --csr cert_request


  ... although since base64 operates on groups of three byte,
it is possible for the message to be misaligned and not readable.
However, since the layout of the certificate is static, it is possible to adjust the message's placement until it works:
this should take less than four attempts.
  

   The result is a functional, trusted certificate with a longish message hidden in the public key.
Renewal is done by resumbitting the CSR and repeating the ACME chalange, which can be automated.
  

  

   Base64 is missing most punctuation, but it provides the full ASCII alphabet,
and the ~150 (RSA-2048) or ~320 (RSA-4096) avalable charaters provides plenty of space for jokes.
Another option would be to target the base16 displayed in most browser's certificate viewer:
this would provide a lot more space (2 chars/byte instea of 0.75), but requires careful word choice.
  

  

   
    As for security
   
   , this trick obviously reduces the entropy in the private key.
However, it should still be secure:
nearly identical methods have been considered as a form of compression.
If the top-half of the modulus is fixed to a well known value, it doesn't have to be sent or stored as part of the key.
  

  

   A reduction of around 1/2 can be achieved through division, but the state of the art can
fix 2/3 of the key, reducing the size to 1/3 of standard RSA while retaining a similar level of security...
although I should note that such tricks have largly been abandoned in favor of other crytosystems which can directly use small keys.
  

  

   The manipulation of q may produce primes that are very close together, which makes it possible to factor n and recover the private key.
A very small d value can also be a problem.
Both of these are unlikely, but my script doesn't check for insecure values
  

  

   However, regardless of the key's security, it should be perfectly fine for a public website:
modern TLS provides forward secrecy, so eavesdropping requires a man-in-the-middle attack even if the private key is compromised.
  

  

   
    Related
   
   :
  

  
   
  
  
 




        

      

    
    

        

          
Midterm Round Up w/Erin Heaney, Chris Melody Fields Figueredo, and Shaira Chaer

        

        

          OrganizingUp
        

	

	  convergencemag.com
	

        

          2026-11-09 19:00:00
        

        

          
          

            Last week’s midterm election results were a massive swing toward Democrats across the country. The Republican trifecta in the federal government has now been broken, creating opportunities to change policies and seek accountability for some of the worst harms of the last 2 years. Meanwhile, direct b...
          

        

        

          
Original Article

          
        

      

    
    

        

          
llm-anthropic 0.31

        

        

          Simon Willison
        

	

	  simonwillison.net
	

        

          2026-11-09 18:58:46
        

        

          
            

          
          

            Release: llm-anthropic 0.31
        Anthropic released Fable 5.2 and Mythos 5.2 today. I've added them to llm-anthropic, so you can now run prompts through Fable 5.2 like this:
uv tool install llm
llm install llm-anthropic
llm keys set anthropic
# paste key here
llm -m claude-fable-5.2 "Generate an ...
          

        

        

          
Original Article

          

 

  

   Anthropic
   
    released Fable 5.2 and Mythos 5.2
   
   today. I've added them to
   
    llm-anthropic
   
   , so you can now run prompts through Fable 5.2 like this:
  

  
uv tool install llm
llm install llm-anthropic
llm keys set anthropic
# paste key here
llm -m claude-fable-5.2 "Generate an SVG of a pelican riding a bicycle"


  

   I ran pelicans at all five reasoning levels -
   
    low
   
   ,
   
    medium
   
   ,
   
    high
   
   ,
   
    xhigh
   
   , and
   
    max
   
   . You can
   
    see them all here
   
   - here's the best result I got, from
   
    xhigh
   
   :
  

  

   It's good - legs the right side of the bicycle, good frame, nice pouch, weird little fingers on the handlebars. The pouch looks slightly misaligned with the top of the beak.
  

  

   
    max
   
   failed to return an image at all, running out of tokens after spending 128,000
   
    thinking about them
   
   . That's the same bug that I saw with
   
    Opus 5.5
   
   - but it's new for the Fable series, both
   
    Fable 5
   
   and
   
    Fable 5.1
   
   returned max effort pelicans just fine.
  

 




        

      

    
    

        

          
Locating the source of a mysterious beep with Claude

        

        

          Simon Willison
        

	

	  simonwillison.net
	

        

          2026-11-09 18:57:21
        

        

          
            

          
          

            Our house has a box room, full of boxes that we still haven't unpacked from our last move. A couple of weeks ago something in that room started intermittently beeping. The beeps were far enough apart that standing in the room and trying to determine the source of the noise was frustrating, and I rea...
          

        

        

          
Original Article

          

 

  

   9th November 2026
  

  

   Our house has a box room, full of boxes that we still haven’t unpacked from our last move. A couple of weeks ago something in that room started
   
    intermittently beeping
   
   . The beeps were far enough apart that standing in the room and trying to determine the source of the noise was frustrating, and I really didn’t want to dig through every one of those boxes. So I had Claude Code build
   
    Beep Locator
   
   , a software system for triangulating the source of a mysterious beep using multiple devices scattered around the room.
  

  

   Here’s what Beep Locator looks like after it has been running for a while:
  

  

   Screenshot of a web app that uses several phones, tablets and laptops as microphones to locate a mystery beeping sound in a room. The left column has an "Add a listener" panel with a QR code and join link, a "Controls" panel with buttons including "Calibrate", "Test beep" and "It just beeped!" plus a "Listen for beeps" checkbox, and a "Mystery beep" note reading "3345 Hz · 3 confirmed · remembered across sessions". Below that, a "Devices" list shows five color-coded listeners (Simon iPhone, New iPad, Old iPad, MacBook Pro, Surface Ultra), each marked "✓ mic working · ✓ speaker working". The main area is a gridded map with a 1 m scale bar that shows the five devices as colored dots and earlier sounds as small timestamped markers. A pink shaded circle near the MacBook Pro is labeled "mystery beep · 2 hearings · within ~41 cm", and beside it a dashed plus marker suggests "add a listener here? could tighten the mystery beep's position by ~12%". Below the map, a "Mystery beep loudness warmer / colder" panel shows a bar for each device: Surface Ultra is loudest at "-6.0 dB ▲ +11.6 dB warmer", with the note "about 6 dB louder means roughly half the distance". At the bottom, a "Sounds located" table lists recent claps and beeps with coordinates, or the warning "arrival times are not physically possible (echo or a different sound?)".
  

  

   You run Python web server to show the primary UI, and then use the QR code or URL to connect as many devices as you can spare to act as listeners—I was using two iPads, a phone, a MacBook Pro and a Surface Ultra.
  

  

   The devices then play noises to each other to help estimate their locations. This didn’t work particularly well, so I added a “Rough mode” where you can drag their icons around in the space to provide rough locations which are then adjusted based on those sounds.
  

  

   Once that’s set up, the devices all listen for the beep!
  

  

   I added a clapping mode too so I could test it by clapping my hands in different locations around the room—displayed as diamonds on the map. This helped me gain confidence that it was capable of locating a sound.
  

  

   Beeps show up on the map as an X, plus a line in the “Sounds located” log. You can replay these sounds (from each device in turn) to confirm they are the mysterious beep you are looking for, then click “This is the mystery beep” to mark them as such.
  

  

   Once you’ve confirmed the mysterious beep frequency the system will listen out for it, measure the interval between beeps, and use the triangulated locations to lock down the most likely location on the map.
  

  

   The system worked as intended. It gave me the position of the beep to within about 40cm, then I dug through that specific pile of boxes and found an ancient carbon monoxide detector that desperately wanted its batteries replaced.
  

  

   How it works
  

  

   When I started working through this problem with Claude it quickly dug up
   
    BeepBeep: A High-Accuracy Acoustic-Based System for Ranging and Localization Using COTS Devices
   
   , a 2007 paper by Chunyi Peng, Guobin Shen, Yongguang Zhang, Yanlin Li, and Kun Tan. Here’s that paper’s abstract:
  

  

   

    We present the design, implementation, and evaluation of BeepBeep, a high-accuracy acoustic-based ranging system. It operates in a spontaneous, ad-hoc, and device-to-device context without leveraging any pre-planned infrastructure. It is a pure software-based solution and uses only the most basic set of commodity hardware – a speaker, a microphone, and some form of device-to-device communication – so that it is readily applicable to many low-cost sensor platforms and to most commercial-off-the-shelf mobile devices like cell phones and PDAs. It achieves high accuracy through a combination of three techniques: two-way sensing, self-recording, and sample counting.
   

  

  

   That sounded exactly like what we needed to build!
  

  

   Beep Locator runs a Python web application server that does most of the work. The listening devices then connect to that server via WebSockets and present a UI which requests browser microphone access. The listeners mainly work by recording a 60 second buffer of recent audio. They also run a simple beep detection algorithm (see
   
    detector.js
   
   ), which uses Fast Fourier Transform and a high-pass filter to identify potential beeps. It sends these events to the main server.
  

  

   When a beep is reported, the server has a device play a short chirp (the device with the lowest round-trip time to the server), then asks every listener upload a clip from about 0.6s before the beep to 0.8s after that chirp. This chirp allows the clips to be aligned with each other, a crucial step in locating the beep.
  

  

   How I built it
  

  

   I started this project using Claude Code Cloud via my iPhone, with Opus 5.5 running in Extra thinking effort mode. Here’s
   
    that shared starter session
   
   , which began with this prompt against a newly created empty GitHub repository:
  

  

   

    
     Write out a problem.md file describing the problem we want to solve
    
   

   

    
     There is a device beeping in a room and I cannot find it
    
   

   

    
     I want to set up several devices - laptops, phones, iPads - around the room all listening at the same time and have them help triangulate where the beep comes from
    
   

   

    
     There needs to be a Python web app which coordinates it all - one device shows a web page for the app, other devices join a URL which turns them into listeners - all via browser WebAudio and WebSockets back to the Python server app
    
   

   

    
     Ideally I wouldn't need to manually input the relative locations of the devices - it would be amazing if they could play sounds to each other in order to locate each other in 2D space - is that even possible though?
    
   

  

  

   That got me
   
    this problem.md file
   
   . As part of writing that up Claude found and read the BeepBeep paper, which is described in that file.
  

  

   The research looked good, so I told it:
  

  

   

    
     Ok try and build it, add a mechanism so you can send new code to the listeners which they will then run automatically - that way I can set everything up in the room and then leave you alone to continue hacking and experiment while I do something else
    
   

  

  

   That got me
   
    to this point
   
   —most of the system was built, but nothing had actually tried running it yet.
  

  

   I cloned the new repository to my laptop and fired up Claude Code... and then
   
    Fable 5.2 was released
   
   , and this project seemed like an excellent opportunity to put that through its paces.
  

  

   I had Claude Code on my laptop start the server running, then made sure it could both see what was happening
   
    and
   
   make live changes to the software as it ran.
  

  

   This was already baked into the software: Opus 5.5 had built an
   
    installModule()
   
   method on the listeners that could be triggered over the WebSocket connection, meaning the admin server could execute arbitrary new code on any of its clients.
  

  

   On some devices, web pages that listen on the microphone request user permission any time the page reloads. The hot-swap module mechanism meant that we could deploy new code without having to manually interact with each of the listening devices in turn.
  

  

   From that point on my involvement was mainly to sit by the laptop chatting with Fable 5.2 about what was going on, and occasionally requesting new features. Here are some of the feature prompts I ran:
  

  

   

    
     I think we need to make it so I can drag things around on the map in “rough mode”, where my job is just to put them roughly where they are, then switch out of rough mode and it attempts to get them accurate
    
   

  

  

   This gave me the ability to drag listeners around the map.
  

  

   

    
     what’s a good way for me to test this I wonder? Can we have it listen for claps, then I could clap and it could identify the location of the clap? [...]
    
   

   

    
     Claps should use a different symbol on the map than beeps
    
   

  

  

   That added the thing where any time I clapped it would show on the map as a different symbol from the beeps.
  

  

   

    
     each symbol on the map should include a HH:MM:SS timestamp
    
   

  

  

   That made it easier to spot which symbol likely reflected which real-world sound.
  

  

   

    
     The log should show beeps and claps with their timestamps AND have a little play button which, when clicked, replays the recorded noise from each of the listeners in sequence (with clear text on screen showing which listener recorded which snippet) while temporarily turning off microphone recording while that replay plays
    
   

  

  

   Now I could replay sounds, making it much easier to identify which recorded clip was the mysterious beep I was looking for.
  

  

   

    
     There should be a button next to a recording for “This is the mystery beep” - then I can hit replay to see and then confirm it was the mystery beep if that’s the one I am looking for
    
   

   

    
     Then the system can categorize noises in the future to see if they are likely that same mysterious beep and use that information to build a more accurate idea of where it is
    
   

  

  

   At this point I was getting close—I had a solid idea of where the beep was coming from, but wouldn’t it be neat if I could reposition the listeners around that point to get an even finer location?
  

  

   

    
     I want a feature for this, I don’t want to have to restart each listening device etc, I want to be able to click a “Reposition the devices” button which lets me switch into repositioning, then I click “Repositioned” and it puts me into Rough mode and asks me to roughly locate them, then I do that and click, then it starts up again. The previous session can be read-only viewed through the app.
    
   

  

  

   And since I had one spare device, I then said:
  

  

   

    
     add a feature where the map includes a spot that is a suggestion for a location that it would be useful to add a listener at - based on data collected so far
    
   

  

  

   Giving Claude Code ears
  

  

   I think the most interesting part of this project is that I demonstrated it’s possible to
   
    give Claude Code ears
   
   .
  

  

   Claude doesn’t have native audio input (yet), but it can run JavaScript and Python code that can analyze audio captured by a microphone.
  

  

   I told it to run a web server with WebSocket connections to multiple listening devices, then had it both run a WebAudio microphone on those devices and hook them up so they could be sent fresh JavaScript code to execute via that WebSocket.
  

  

   Then I could pretty much leave Claude alone, hacking away at the problem, querying the audio logs, and reconfiguring its ears to help it solve the problem.
  

  

   I’m reminded of a similar hack I heard about at GitHub Universe a few weeks ago, where
   
    Martin Woodward
   
   told me he had been debugging the
   
    GitHub Badge computers
   
   by plugging them into a computer via USB-C and then pointing a webcam at their screen, so his coding agent could tell if updates were working correctly or not.
  

  

   Figuring out ways to let coding agents perceive the world around them is a whole lot of fun.
  

 




        

      

    
    

        

          
Vanderbilt University hit in BYOD ransomware attack, data theft claimed

        

        

          Bleeping Computer
        

	

	  www.bleepingcomputer.com
	

        

          2026-11-09 18:52:12
        

        

          
            

          
          

            Vanderbilt University warns it is responding to a cyberattack claimed by the BYOD ransomware gang, which claims to have encrypted the university's databases and stolen sensitive student, employee, and research data. [...]...
          

        

        

          
Original Article

          

 

  

   Vanderbilt University
  

  

   Vanderbilt University warns it is responding to a cyberattack claimed by the BYOD ransomware gang, which claims to have encrypted the university's databases and stolen sensitive student, employee, and research data.
  

  

   The university confirmed the incident Monday, warning that university devices, systems, and cloud-based services may be affected.
  

  

   "We are currently responding to an active cybersecurity incident that may impact university devices, systems, and cloud-based services. Our Information Technology team is actively investigating and working to contain the situation," Vanderbilt said in a
   
    statement on X
   
   .
  

  

   
    image
   
  

  

   As part of its response, the university told students, faculty, and staff to shut down university devices, disconnect from university Wi-Fi, and watch for suspicious activity.
  

  

   The university warned that signs of compromise may include unexpected pop-ups or security notifications, unusual changes to files or permissions in cloud storage platforms, missing or modified files, unfamiliar applications, and unexpected authentication requests.
  

  

   Those who notice suspicious activity were instructed not to investigate or troubleshoot the issue themselves, but instead immediately shut down their devices and contact the university's IT service desk.
  

  

   Vanderbilt has not publicly disclosed the nature of the attack or confirmed whether any data was stolen.
  

  

   BleepingComputer contacted Vanderbilt University with questions about the attack, including whether systems were encrypted, what data may have been stolen, and whether the incident has been contained.
  

  

   If you have any information regarding this incident or other undisclosed attacks, you can contact us confidentially via Signal at 646-961-3731 or at tips@bleepingcomputer.com.
  

  

   BYOD ransomware claims attack
  

  

   On Monday, the BYOD ransomware group claimed responsibility for the attack on its data leak site, alleging that it had encrypted Vanderbilt's databases and stolen sensitive information belonging to students and employees.
  

  

   "If you could not tell already, your databases are locked, We have your entire estate and research data. Over 1 Million SSNs, Full Names, Email addresses, Phone Numbers, Student & Employee Records, Full takeover of your DC, whatever was on your network, we possess," reads the BYOD data leak site.
  

  

   

    BYOD ransomware group claims attack on Vanderbilt University
    

     
      BYOD ransomware group claims attack on Vanderbilt University
     
     

     
      Source: BleepingComputer
     
    

   

  

  

   BleepingComputer has since received a photograph of an alleged computer screen showing icons associated with Vanderbilt University and displaying a BYOD ransom note named "README_BYOD_31.txt".
  

  

   The ransom note includes a link to the BYOD data leak site and contact information for the SESSION encrypted messaging platform to negotiate with the ransomware gang. BleepingComputer can confirm that the link in the ransom note is the site operated by BYOD.
  

  

   "Oh no, you have been compromised by BYOD :<," reads the ransom note.
  

  

   "We have all of your data including your backups, your entire network is compromised."
  

  

   "Yes, this affects your student and employee data the most, every single SSN is archived, full names, email addresses, phone numbers, work addresses, roles, birthdays, quite literally everything."
  

  

   

    Photograph of BYOD ransom note displayed on a Vanderbilt University computer
    

     
      Photograph of BYOD ransom note displayed on a Vanderbilt University computer
     
     

     
      Source: BleepingComputer
     
    

   

  

  

   The note also threatens to release stolen data and cause further disruption if the university does not negotiate with the attackers.
  

  

   A video shared on YouTube and with BleepingComputer also shows how infected devices are playing audio warning that the network has been compromised by "BYOD".
  

  

   
  

  

   While the ransom note and video indicate BYOD is behind the attack, Vanderbilt has not officially confirmed the group's involvement or whether devices were encrypted.
  

  

   BYOD is a relatively new ransomware gang that launched in 2026 and currently lists 5 other organizations on its data leak site.
  

  

   Last month, the ransomware gang claimed responsibility for an
   
    attack on the University of New Mexico Health Sciences Center
   
   in a cyberattack that caused system outages and disrupted patient care and academic activities.
  

  

   

    
     article image
    
   

   

    

     
      Uncover email threats your existing defenses may miss.
     
    

    

     Adaptive Security's AI agents analyze email intent, context, and behavior to uncover phishing, business email compromise, and invoice fraud.
    

    

     See what's getting through with a 14-day read-only scan of Microsoft 365 or Google Workspace, with no MX changes.
    

    

     
      Start your free email security scan.
     
    

   

  

 




        

      

    
    

        

          
Bloomberg Was Onto Megaspeed’s Game a Year Ago

        

        

          Daring Fireball
        

	

	  www.bloomberg.com
	

        

          2026-11-09 18:46:17
        

        

          
          

            Mackenzie Hawkins, Andy Lin, and Kari Soo Lindberg, reporting for Bloomberg last year on December 22 (Archive.today link):


  In an industry run by titans, a Singapore AI firm called Megaspeed
International Pte. is drawing an unusual amount of attention. In
less than three years, the once-obscure s...
          

        

        

          
Original Article

          

 

  

   We've detected unusual activity from your computer network
  

  

   To continue, please click the box below to let us know you're not a robot.
  

 

 

  

   

    Why did this happen?
   

   

    Please make sure your browser supports JavaScript and cookies and that you are not
                    blocking them from loading.
                    For more information you can review our
    
     Terms of Service
    
    and
    
     Cookie Policy
    
    .
   

  

  

   

    Need Help?
   

   

    For inquiries related to this message please
    
     contact
                        our support team
    
    and provide the reference ID below.
   

   

    Block reference ID:b6400047-dc9a-11f1-b595-88fe45473414
   

  

  

   

    Get the most important global markets news at your fingertips with a
    
     Bloomberg.com
    
    subscription.
   

   
    SUBSCRIBE NOW
   
  

 




        

      

    
    

        

          
10 Reasons Hakeem Jeffries Should Not Be House Speaker

        

        

          Portside
        

	

	  portside.org
	

        

          2026-11-09 18:41:34
        

        

          
          

            10 Reasons Hakeem Jeffries Should Not Be House Speaker

Mark Brody

Mon, 11/09/2026 - 18:41

...
          

        

        

          
Original Article

          

 

  

   Now that Democrats have swept the House, a key question is: Who should lead it?
  

  

   
    
     Hakeem Jeffries
    
   
   is in line to become the first Black Speaker of the House, which would be a historic milestone. But members of Congress must examine Jeffries’ record, his priorities, and the kind of leadership he would bring to this moment.
  

  

   Here are ten reasons why Jeffries should not be Speaker.
  

  

   
    1. He has abandoned Medicare for All
   
  

  

   At a time when millions of Americans struggle with unaffordable health insurance, medical debt, and the threat of financial ruin from illness, Jeffries has distanced himself from one of the most important progressive reforms:
   
    
     Medicare for All
    
   
   .
  

  

   Jeffries co-sponsored
   
    
     Medicare
    
   
   for All legislation from 2013 through 2021. But in an August 2026 interview on NBC’s
   
    Meet the Press
   
   , he said it is no longer legislation he supports or cosponsors. Ironically, he made that statement on the same day a CBS poll found that 90 percent of Democratic voters back the idea.
  

  

   This reversal puts him at odds with party voters, but also with a majority of Democratic representatives in the House. As of late October, Rep. Pramila Jayapal’s Medicare for All Act had 118 Democratic cosponsors. A “leader” who won’t back what his own caucus and voters want is not a leader.
  

  

   
    2. He refuses to break with Israel
   
  

  

   Perhaps nowhere is Jeffries more out of step with the progressive base than on Israel.
  

  

   For decades, Jeffries has been a staunch defender of the U.S.-Israel alliance. At a pro-Israel rally in 2014, during Israel’s military assault on
   
    
     Gaza
    
   
   , Jeffries proclaimed, “Israel today, Israel tomorrow, Israel forever!.” In 2020 he told an
   
    
     AIPAC
    
   
   conference that New Yorkers consider Jerusalem their “sixth borough,” totally disregarding the plight of
   
    
     Palestinians
    
   
   living under Israeli occupation.
  

  

   Even as Israel’s
   
    
     genocide
    
   
   in
   
    
     Gaza
    
   
   sparked worldwide outrage, Jeffries continued to resist calls to end
   
    
     U.S. military
    
   
   support.
  

  

   In July 2026, 103
   
    
     House Democrats
    
   
   voted to cut $3.3 billion in military aid to Israel, including the party’s second-ranking House leader, Katherine Clark. But Jeffries joined 97 other Democrats and nearly every Republican in voting to preserve the funding.
  

  

   In a May 2024
   
    60 Minutes
   
   interview, when asked whether Israel’s bombing of Gaza had been indiscriminate, Jeffries said no. By then, nearly 35,000 Palestinians had been killed. When the interviewer pressed him, saying, “You seem reluctant to criticize Israel at all,” Jeffries responded, “I’m dealing with the facts on the ground.”
  

  

   Jeffries has also refused to cosponsor the Block the Bombs Act, which would restrict transfers of some of the deadliest offensive weapons to Israel, including 2,000-pound bombs, bunker busters, precision-guidance kits, and tank and artillery rounds. As of November 2026, the bill has 82 Democratic cosponsors and the endorsement of the Congressional Progressive Caucus. Caucus Chair
   
    
     Greg Casar
    
   
   has pledged to push for a floor vote if Democrats regain the majority. Yet Jeffries has not signed on, and as Speaker, he would have enormous power to determine whether the bill ever receives a vote.
  

  

   While Jeffries has acknowledged that U.S. policy toward Israel needs to change, he continues to support Israel’s military superiority and joint missile-defense programs. He has also refused to condemn Section 219 of the NDAA, which would further integrate U.S. and Israeli military research,
   
    
     technology
    
   
   , and production.
  

  

   Ironically, both
   
    
     Donald Trump
    
   
   and
   
    
     Benjamin Netanyahu
    
   
   have recently suggested that the U.S. should stop giving Israel nearly $4 billion a year because “Israel doesn’t need it.” Whether or not we believe them, it is striking that we have yet to hear a similar call from Hakeem Jeffries.
  

  

   
    3. He has failed to champion major cuts to the obscene Pentagon budget
   
  

  

   At a time when Americans are struggling to afford basic necessities, Trump is demanding a staggering $1.5 trillion military budget—an increase of nearly $600 billion, or 66 percent, over the previous year’s base funding. Yet Jeffries has not made substantially reducing
   
    
     Pentagon
    
   
   spending a central priority of Democratic leadership.
  

  

   Yes, he has opposed funding for Trump’s war in Iran but he is a staunch advocate of continued U.S. military aid to
   
    
     Ukraine
    
   
   and has sharply criticized Trump for failing to provide sufficient support. He said “America is stronger when Russia is weaker.” In September 2026, he pledged that Democrats would continue backing Ukraine “until victory is won,” signaling his commitment to greater U.S. involvement and military assistance instead of a commitment to a diplomatic solution that would end that terrible war.
  

  

   Jeffries is also an enthusiastic defender of the aggressive alliance
   
    
     NATO
    
   
   , which should have dissolved when the Soviet Union fell apart in 1991. He has called NATO “the most successful military and diplomatic alliance in the history of the world.” NATO, at Trump’s insistence, has called for all members to dramatically increase their military budgets to 5 percent of their GDP (the US is presently at 3.1 percent).
  

  

   Jeffries’ ties to the
   
    
     military-industrial complex
    
   
   are particularly troubling. During the 2026 election cycle alone, Jeffries’ campaign reportedly received approximately $212,000 from military PACs.
  

  

   Democrats cannot simply promise better
   
    
     healthcare
    
   
   ,
   
    
     affordable housing
    
   
   , quality education and climate action while supporting a massive military
   
    
     budget
    
   
   . Real change requires shifting resources from weapons and war to the needs of ordinary people. The next Democratic Speaker must be prepared to challenge the military-industrial complex.
  

  

   
    4. He continues to accept pro-Israel lobby money
   
  

  

   Jeffries’s position on Israel cannot be separated from his longstanding political relationship with the
   
    
     AIPAC
    
   
   lobby.
  

  

   At a time when AIPAC funding has become toxic and so many Democratic candidates rejected AIPAC money, Jeffries has maintained his ties to the organization.
  

  

   According to Track AIPAC, Hakeem Jeffries has received more than $1.5 million in campaign contributions from AIPAC and other pro-Israel lobby groups over his congressional career. During the 2026 election cycle alone, his campaign received nearly $300,000 in contributions from pro-Israel PACs.He has also taken five AIPAC-sponsored trips to Israel since arriving in Congress.
  

  

   Following the November elections, AIPAC publicly celebrated Jeffries as one of the candidates it supported.
  

  

   How can congressional Democrats be led by someone so closely tied to AIPAC, a lobby increasingly toxic to their own voters?
  

  

   
    5. His Backroom Dealings with Jared Kushner Raise Serious Questions About His Judgment
   
  

  

   At a time when Americans are demanding investigations into the Trump family’s financial dealings, Hakeem Jeffries chose to sit down privately with
   
    
     Jared Kushner
    
   
   , Trump’s son-in-law and influential adviser.
  

  

   In August 2026, reports revealed that Jeffries had met with Kushner to discuss possible cooperation on housing,
   
    
     immigration
    
   
   and affordability. Yet Kushner, who holds no official government position, continues to wield influence over U.S. foreign policy while maintaining lucrative financial relationships with Gulf governments through his investment firm.
  

  

   House Judiciary Committee Democrat
   
    
     Jamie Raskin
    
   
   has already launched an investigation into Kushner’s foreign financial entanglements, demanding documents and communications about his dealings with foreign governments. So why was Jeffries meeting with him behind closed doors?
  

  

   With Democrats taking control of the House in January, they need a speaker committed to untangling the dirty web of
   
    
     corruption
    
   
   committed by Trump and his inner circle.
  

  

   
    6. He Has Elevated Warhawks to Key Foreign-Policy Positions
   
  

  

   You can tell a political leader’s priorities by whom they put in power. And Jeffries’s choices speak volumes.
  

  

   In August 2026, Democratic leaders elevated Rep. Jared Moskowitz, one of the House’s most outspoken pro-Israel hawks, to the top Democratic position on the powerful House Foreign Affairs Subcommittee on the Middle East and North
   
    
     Africa
    
   
   . Moskowitz has been an unwavering defender of Israel’s genocide in Gaza, continued U.S. weapons shipments, and Israel’s brutal military operations in
   
    
     Lebanon
    
   
   . He has also openly supported both Israeli attacks on Iran and Trump’s 2025 bombing of Iranian nuclear facilities, and initially opposed congressional efforts to prevent the 2026 war before later backing War Powers restrictions.
  

  

   With Democrats in control of the House, Moskowitz will be positioned to chair the Middle East and North Africa Subcommittee, wielding significant influence over congressional oversight and policy toward Israel,
   
    
     Palestine
    
   
   , Iran, and the entire region.
  

  

   Debbie Wasserman Schultz and Wesley Bell, two other staunch defenders of Israel, were added to the Foreign Affairs Committee. Bell had defeated progressive Rep.
   
    
     Cori Bush
    
   
   in 2024 after massive spending by AIPAC’s super PAC.
   
    
     Progressives
    
   
   are still steaming over the role of Wasserman Schultz in undermining
   
    
     Bernie Sanders
    
   
   during the 2016 Democratic presidential primary.
  

  

   The backlash to these appointments was immediate. Rep.
   
    
     Ro Khanna
    
   
   warned, “Don’t put Israel hawks out of touch with our voters in charge of our Middle East policy.” The Council on American-Islamic Relations condemned the appointments as an insult to voters and an attempt to shield Israel from accountability for its actions in Gaza.
  

  

   
    7. Jeffries Represents the Democratic Party's Dependence on Corporate Money
   
  

  

   The
   
    
     Democratic Party
    
   
   claims to fight for working people, but Jeffries remains deeply connected to the wealthy corporate interests that dominate
   
    
     Washington
    
   
   .
  

  

   His campaign has benefited from millions of dollars in contributions associated with
   
    
     Wall Street
    
   
   , pharmaceutical and insurance companies, real estate interests,
   
    
     Big Tech
    
   
   and military contractors.
  

  

   These financial relationships raise a fundamental question: How aggressively will Democrats challenge
   
    
     corporate greed
    
   
   , Wall Street speculation, soaring healthcare costs and the military-industrial complex when their leader maintains such close ties to these powerful interests?
  

  

   Progressive Democrats have demonstrated that grassroots organizing and small-dollar fundraising offer an alternative to corporate PAC money.
  

  

   The Democratic Party cannot credibly promise to take on
   
    
     corporate power
    
   
   without confronting the influence of big money within its own leadership.
  

  

   
    8. He has defended the Democratic establishment against progressive challengers
   
  

  

   Jeffries has a long history of protecting entrenched Democratic incumbents against progressive challengers.
  

  

   In 2020, he backed longtime pro-Israel congressman
   
    
     Eliot Engel
    
   
   against
   
    
     Jamaal Bowman
    
   
   , who defeated Engel in a stunning primary upset. In 2022, Jeffries traveled to Chicago to campaign for veteran Congressman Danny Davis against young progressive organizer Kina Collins, who came within seven percentage points of victory.
  

  

   And in 2026, Jeffries backed Dan Goldman, Adriano Espaillat and Shri Thanedar against progressive challengers Brad Lander, Darializa Avila Chevalier and Donavan McKinney. All three incumbents lost their primaries, and all three challengers went on to win in November.
  

  

   This pattern is no coincidence. In 2021, Jeffries joined forces with centrist Democrats Josh Gottheimer and Terri Sewell to establish Team Blue PAC, designed to protect Democratic incumbents against primary challengers.
  

  

   While voters are demanding a new direction, Jeffries has repeatedly sided with the establishment candidates they rejected.
  

  

   
    9. He Wants to Reform ICE, Not Abolish It
   
  

  

   As ICE agents terrorize immigrant communities, separate families and carry out violent raids, the question of how to dismantle Trump’s cruel mass-deportation machinery has become increasingly urgent.
  

  

   Jeffries has condemned ICE’s brutality and demanded greater accountability. But he has stopped short of calling for the abolition of ICE or the dismantling of the Department of Homeland Security, insisting instead that these agencies can be reformed.
  

  

   Contrast that with Rep. Delia Ramirez’s groundbreaking Reimagining Safety Act, which would abolish ICE, dismantle DHS and establish a new Department of Community Safety, redirecting resources toward housing, healthcare and community well-being. Her legislation challenges the very definition of national security, arguing that real safety comes from meeting people’s needs, not militarizing their communities.
  

  

   This is the kind of bold, visionary leadership that offers a fundamental alternative to simply “reforming” an out-of-control immigration enforcement system that is terrorizing immigrant communities.
  

  

   
    10. He Has Failed to Champion Bold Climate Action
   
  

  

   As devastating
   
    
     wildfires
    
   
   consume entire communities, record-breaking heat waves threaten lives, and floods and droughts wreak havoc across the country, the
   
    
     climate crisis
    
   
   demands bold, urgent leadership—not business as usual.
  

  

   Yet Jeffries has refused to endorse the
   
    
     Green New Deal
    
   
   or champion demands to halt the expansion of fossil fuel
   
    
     infrastructure
    
   
   and eliminate taxpayer subsidies to the
   
    
     oil
    
   
   and gas industry. In 2022, when more than 70 House Democrats publicly opposed legislation to fast-track fossil fuel projects, Jeffries declined to join them.
  

  

   More recently, he has distanced himself from calls for a moratorium on new AI data centers, even as a powerful grassroots movement is sweeping the country, with communities organizing against these energy-guzzling facilities that drain
   
    
     water
    
   
   supplies, drive up electricity bills, strain power grids and threaten the environment.
  

  

   Jeffries supported the
   
    
     Inflation
    
   
   Reduction Act’s clean-energy investments, but he has not embraced the more ambitious climate agenda advocated by progressive lawmakers and community groups.
  

  

   At a time when climate disasters are destroying homes, livelihoods and entire communities, the Democratic Party needs leadership with the urgency and ambition to confront the climate crisis.
  

  

   
    A Democratic Majority Deserves Progressive Leadership
   
  

  

   More than any single vote, contribution, or appointment, the problem with Hakeem Jeffries is the establishment politics he represents—politics that protect the powerful, accommodate corporate interests, and offer timid reforms when the country is crying out for transformative change.
  

  

   Voters did not reject Republican
   
    
     extremism
    
   
   just to see Democratic leaders continue pouring billions into wars and corporate interests while families struggle to afford housing, healthcare, and basic necessities.
  

  

   And the grassroots are making their voices heard. In just a few days, more than one million people have signed a petition demanding new leadership. Congressional offices are being inundated with calls, and several incoming Democrats—including Melat Kiros, Claire Valdez, Chris Rabb, and Adam Hamawy—are withholding support for Jeffries.
  

  

   The Speaker of the House holds enormous power. That power can be used to confront the military-industrial complex, challenge corporate money and AIPAC, stand up for immigrants, and put human needs ahead of endless wars. Or it can be used to protect the very system that has brought us to this crisis.
  

  

   That’s why we need a new generation of leadership willing to fight for real change.
  

  

   Sign the
   
    
     petition demanding new leadership
    
   
   . Call your member of Congress at
   
    
     202-224-3121
    
   
   .
  

  

   
    
     Medea Benjamin is co-founder of Global Exchange and CODEPINK: Women for Peace. She is the co-author, with Nicolas J.S. Davies, of War in Ukraine: Making Sense of a Senseless Conflict, available from OR Books in November 2022. Other books include, "Inside Iran: The Real History and Politics of the Islamic Republic of Iran" (2018); "Kingdom of the Unjust: Behind the U.S.-Saudi Connection" (2016); "Drone Warfare: Killing by Remote Control" (2013); "Don't Be Afraid Gringo: A Honduran Woman Speaks from the Heart" (1989), and (with Jodie Evans) "Stop the Next War Now" (2005).
    
   
  

 




        

      

    
    

        

          
Tracking the Harm of DOGE Cuts

        

        

          Hacker News
        

	

	  www.clasp.org
	

        

          2026-11-09 18:40:54
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   The DOGE Tracker, CLASP’s interactive data tool, is designed to help users explore and document the proposed reductions to federal programs under review by the Department of Government Efficiency (DOGE). This sortable, filterable spreadsheet compiles program-level information on funding changes—either proposed or enacted—during the current administration. The goal of the DOGE Tracker is to support transparency by providing accessible, regularly updated data to policymakers, researchers, and advocates monitoring the scope and impact of federal budget decisions. All entries include source documentation, relevant timelines, and links to official materials where available.
  

  

   
    Agency Key
   
  

  

   
  

  

   
    

     
      Government Agency
     
     
      DOGE Federal Layoffs
     
     
      Programs Impacted
     
     
      Number of Households or People at Risk
     
    

   
   
    

     
      
       Centers for Disease Control and Prevention's The National Center for HIV, Viral Hepatitis, STD, and Tuberculosis Prevention
      
     
     
      Overall, 2,400 federal layoffs or roughly 18 percent of the CDC's workforce. The Center on HIV and STD Prevention saw 27 percent of its 1,700 staff eliminated.
     
     
      The CDC's National Center for HIV, Viral Hepatitis, STD, and Tuberculosis Prevention works to ensure a future free of HIV, viral hepatitis, sexually transmitted diseases, and tuberculosis. The Center works to reduce incidence of infection, morbidity and mortality, and health disparities in the U.S. and abroad.
     
     
      From 2007 to 2010, the CDC-funded Expanded Testing Initiative sites provided more than 2.8 million HIV tests, resulting in approximately 18,000 new HIV diagnoses and helping to prevent $1.2 billion in direct medical costs.
      

       Since then, approximately one-third of all new HIV diagnoses in 2013 were through a CDC-funded HIV test.
      

      

       
        >>Source
       
      

     		
    

    

     
      
       Centers for Disease Control and Prevention's National Institute for Occupational Safety and Health (NIOSH)
      
     
     
      Complete elimination of department (1600 federal layoffs).
     
     
      The CDC's National Institute for Occupational Safety and Health prevents work-related illness, injury, disability, and death by gathering information, conducting scientific research, and translating the knowledge gained into products and services.
     
     
      The assault on NIOSH halts services and stops activities critical to the function of the agriculture workforce. such as protecting thousands of workers from H5N1 bird flu. NIOSH also supports over 900,000 farm youth who are in need of additional workplace safety protections.
      

      
       >>Source
      
     		
    

    

     
      
       Department of Health & Human Services’ Administration for Children & Families
      
     
     
      ~700 total ACF layoffs.
      

       ~50% cuts to the Office of Child Care (OCC).
      

      

       ~40-50% cuts to Head Start offices, including 12 regional offices. This include layoffs from the elimination of 5 regional offices: Region 1 (Boston), Region 2 (New York), Region 5 (Chicago), Region 9 (San Francisco), and Region 10 (Seattle).
      

     		
     
      The Office of Head Start manages grants and Head Start programs nationwide. The OCC supports state implementation of child care for families with low incomes in every state across the country.
     
     
      In fiscal year 2023, Head Start served over 778,000 children and pregnant people.
      

       In 2022, the Child Care and Development Fund served 1,434,900 children.
       

       
        >>Source
       
      

     		
    

    

     
      
       Department of Homeland Security, The Office for Civil Rights and Civil Liberties (CRCL)
      
     
     
      Over 100 federal layoffs; complete elimination of department.
     
     
      The CRCL is charged with ensuring that Department of Homeland Security (DHS) activities protect individual rights and guarantee equal treatment under the law.
     
     
      Without the CRCL, there will be no internal watchdog offices left at DHS to assess the legality and effectiveness of, and problems with, the implementation of Trump Administration policies on immigration enforcement.
      

       
        >>Source
       
      

     		
    

    

     
      
       Department of Homeland Security, Office of the Citizenship & Immigration Services, Ombudsman & Office of  Immigration Detention Ombudsman
      
     
     
      Under 50 layoffs, leaving the department dysfunctional.
     
     
      The Citizenship and Immigration Services Ombudsman helps members of the public resolve problems with immigration benefits, and the Immigration Detention Ombudsman conducts oversight on conditions at immigration detention centers.
     
     
      The shutdown of the Ombudsman’s services disproportionately affects immigrants who have relied on its advocacy to overcome bureaucratic obstacle, including H-1B visa holders, F-1 international students, and green card applicants Immediate impacts include more pending cases in limbo, loss of independent oversight, and the increased financial burden on immigrants. Without the Ombudsman, more immigration applicants will likely turn to attorneys and will have to resort to costly processing options to avoid delays in their cases.
      

       
        >>Source
       
      

     		
    

    

     
      
       Internal Revenue Service
      
     
     
      7,000 federal layoffs; 5,000 of those layoffs toward workers in tax compliance efforts; additional plans to slash 45,000 more jobs.
     
     
      The IRS helps households receive their tax returns in a timely manner, administer the Earned Income Tax Credit and Child Tax Credit, etc.
     
     
      With 50k layoffs, the U.S. will lose $12.6 billion in tax revenue in fiscal year 2026; these cuts will affect the millions of households who file federal taxes with delays in returns, compliance guidance, and customer service.
      

      
       >>Source
      
     		
    

    

     
      
       Department of Education's Office of Civil Rights (OCR)
      
     
     
      240 federal layoffs, including all staff at the 12 regional OCR across the country.
     
     
      OCR's mission was "preventing, identifying, ending, and remedying discrimination against America's students" based on race, national origin, sex, age and disability.
     
     
      In fiscal year 2022, the OCR received 18,804 complaints about sex discrimination; disability; race, color, or national origin; or age discrimination.
      
       >>Source
      
     
    

    

     
      
       Department of Education's Institute for Research Sciences (IES)
      
     
     
      More than 100 federal research analysts who specialize in K-12 studies and adult and career education.
     
     
      The IES is the research division of the Department of Education and administers large-scale efforts studies across K-12 to higher education. .
     
     
      The research collected by IES is used by educators, state and local departments of education, school districts, colleges, and other researchers to better understand student achievement, enrollment, and a host of other important functions that shape the education system in this country.
      

       
        >>Source
       
      

     		
    

    

     
      
       Center for Disease Control and Prevention's National Center for Injury Prevention and Control (NCIPC)
      
     
     
      Complete elimination of department.
     
     
      NCIPC studies how to prevent gun violence, child abuse, and elder abuse.
     
     
      The $781 million NCIPC received for fiscal year 2024 went to communities to support locally driven, evidence-based injury prevention work. Together, injuries and violence cost the U.S, more than $4 trillion annually.
      

      
       >>Source
      
     		
    

    

     
      
       Center for Disease Control and Prevention's National Center for Chronic Disease Prevention and Health Promotion
      
     
     
      Complete elimination of department.
     
     
      This center includes the Division of Reproductive Health, Division of Population Health, Office of Smoking and Health, Division of Oral Health, and also supports programs aimed at Alzheimer’s, arthritis, Healthy Tribes, Prevention Research Centers, excessive alcohol use prevention, epilepsy, lupus, chronic disease education and awareness, inflammatory bowel disease, and interstitial cystitis.
     
     
      From 2012 to 2018, 16.4 million smokers attempted to quit and 1 million successfully quit because of the Tips® campaign. The Million Hearts® initiative prevented an estimated 135,000 cardiac events from 2012 to 2016, averting $5.6 billion in medical costs. Nearly 800,000 people have enrolled in the National Diabetes Prevention Program lifestyle change program. Since 1991, the National Breast and Cervical Cancer Early Detection Program has served more than 6.2 million women. Nearly 2 million middle and high school students are served by the CDC's What Works in Schools program, which improves students' mental health and reduces substance use, sexual risk behavior, and experiences of violence.
      

      
       >>Source
      
     		
    

    

     
      
       National Institute of Health
      
     
     
      1,200 federal layoffs, with more expected.
     
     
      The world's largest public funder of biomedical research; funds nearly $48 billion in scientific research outside the agency.
     
     
      NIH grants support more than 300,000 medical researchers and 2,500 institutions, including hospitals, medical schools, and universities.
      

      
       >>Source
      
     		
    

    

     
      
       Social Security Administration
      
     
     
      7,000 employees by September (though some may be voluntary "fork in road" departures).
     
     
      Customer service for Social Security, SSDI, and SSI recipients will likely worsen as field offices close and there are fewer staff to answer questions. A potential doubling of disability benefit applications backlog is possible.
     
     
      In 2023, 71.6 million people received benefits administered by SSA, with 5.8 million people being newly awarded benefits. They are at risk if customer service capacity declines and backlogs increase.
      

       
        >>Source
       
      

     		
    

    

     
      
       Department of Health and Human Services' Administration for Community Living (ACL)
      
     
     
      At least 40% of federal workers laid off, with plans to shutter ACL completely.
     
     
      ACL coordinates federal policy on aging, disability, and anti-poverty programs.
     
     
      The agency funds and works with over 2,500 community organizations nationwide including senior centers, centers for independent living, developmental disabilities, and more. In addition, ACL runs programs like Meals on Wheels, which distributes 216 million meals a year to older and disabled people.
      

      
       >>Source
      
     		
    

    

     
      
       Department of Health and Human Services' Divison of Energy Assistance
      
     
     
      24 federal layoffs.
     
     
      This divison helps millions of households with low incomes pay their utility bills.
     
     
      This division within HHS serves approximately 6.2 million households annually and is a $4.1 billion program.
      

      
       >>Source
      
     		
    

    

     
      
       Food and Drug Administration (FDA)
      
     
     
      3,500 federal layoffs.
     
     
      Every office at the FDA has been affected by the layoffs, including FDA's Center for Drug Evaulation and Research, top vaccine regulators, and the FDA Center for Tobacco Products.
     
     
      The FDA protects public health by regulating prescription drugs, medical devices, vaccines, and food safety; it affects nearly every household in the country.
      

      
       >>Source
      
     		
    

    

     
      
       National Oceanic and Atmospheric Administration (NOAA)
      
     
     
      1,300 federal layoffs.
     
     
      NOAA's National Weather Service, Geophysical Fluid Dynamics Laboratory, National Centers for Environmental Information, and Atlantic Oceanographic and Meterological Lab.
     
     
      NOAA oversees many institutions that collect and clean data for tracking the weather and climate change. Fewer employees means less accurate weather forecasts and assessments of the human impact on climate change on the national level and for international partners that rely on the infrastructure the U.S. has in place to gather said data.
      

      
       >>Source
      
     		
    

   
  

  
 




        

      

    
    

        

          
The race to secure record-like information for domains

        

        

          Lobsters
        

	

	  alexsci.com
	

        

          2026-11-09 18:25:03
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  
   Built on Shards of Silicon
  
  

  

   It’s sort of surprising, but we’re still figuring out how to secure simple, record-like information for domain names in an application-accessible way.
  

  

   Think about it. How would you bind the following to a domain name?
  

  
example.com
    Key-1: Value-1
    Key-2: Value-2


  

   Importantly, how would you secure it?
  

  

   DNS and DNSSEC
  

  

   Since we’re talking about domain names, lets start with DNS. The classic solution adds configuration as TXT records:
  

  
_PROTOCOL.EXAMPLE.COM.  IN  TXT   "v=PROTOCOLv1; Key-1=Value-1; Key-2=Value-2"


  

   Notice that we use an underscored subdomain label to make it clear we aren’t talking about a hostname. The protocol name is then repeated to make it abundantly clear this record is related to the protocol.
  

  

   As is, we can’t claim this solution is secure. DNS-based network interference is trivial and widespread. The best practice for securing DNS records is DNSSEC, which uses cryptographic signing.
  

  

   I’m not going to debate the security properties of DNSSEC in this post. There are strong opinions on both sides and the most helpful answer likely depends on the context in which you work. For the sake of this blog post I’ll wave my hands and call this “secure enough” to side-step the issue. In any case, the rest of the post doesn’t depend on a favorable or unfavorable assessment of the security properties of DNSSEC.
  

  

   DNSSEC is uncommon
  

  

   Even the strongest supporters of DNSSEC need to face the reality that DNSSEC isn’t widely adopted.
  

  

   There’s no single answer that quantifies DNSSEC adoption.
At Fox Loop Software I collect adoption metrics for various Internet protocols;
   
    we just released the first dashboard
   
   .
Our approach highlights that adoption rates vary widely depending on which cohort you measure.
For example, here are the adoption rates of DNSSEC signed MX records among second-level domain names that accept email:
  

  

   
    

     
      Cohort
     
     
      Adoption rate
     
    

   
   
    

     
      Tranco top 1,000
     
     
      12.3%
     
    

    

     
      Tranco top 1,000,000
     
     
      7.5%
     
    

    

     
      .COM
     
     
      1.4%
     
    

    

     
      .GOV
     
     
      10.4%
     
    

    

     
      .SE
     
     
      62.8%
     
    

   
  

  

   From the perspective of an application developer, it is not reasonable to expect that a customer domain name will support DNSSEC. Until this changes, application developers must use alternate solutions if they need security.
  

  

   The web approach
  

  

   If my application is web-based then there’s a pretty obvious solution as I already have an HTTPS secured endpoint.
I can use the HTTPS .well-known approach (
   
    RFC 8615
   
   ).
  

  
GET https://example.com/.well-known/protocol.txt
---
Version: PROTOCOLv1
Key-1: Value-1
Key-2: Value-2


  

   These records are secured by HTTPS.
The developer experience is excellent: adding a record could be as easy as dropping a file in a web server directory.
Fetching records is a simple HTTP GET request.
  

  

   But not everything is a web-based application. Can we extend this solution to other protocols?
  

  

   Case study: Email
  

  

   Email is a very old protocol, predating not only TLS but the entire Internet as well.
Over time all sorts of additions have been bolted on to modernize and maintain the protocol.
Many of these additions added new DNS TXT records, such as SPF, DKIM, and DMARC.
These records can be secured by DNSSEC but do not require it, so tampering of these records is unmitigated or otherwise tolerated.
  

  

   Let’s look past these examples to a problem that clearly requires a secure record.
  

  

   The hostname mis-match problem
  

  

   Email has an awkward problem, which is how hostnames are managed.
When a message transfer agent (MTA) relays an email it needs to discover the destination MTA.
This is solved using an MX record, which specifies the target MTA’s domain name.
I’ve measured that around 80% of domains host their email on a different domain name, often using providers like Google or Microsoft.
  

  

   When sending an email, the MTA will discover a chain from the user’s email address to the receiving MTA’s TLS certificate, like this:
  

  

   
    A diagram showing a chain from 'example.com' in the email address 'user@example.com', to an MX record linking 'example.com' to 'smtp.provider.com', and ending with the TLS certificate subject alternative name of 'smtp.provider.com'.
   
   

    

     An insecure chain from the email address to the TLS certificate
    

   

  

  

   The sending MTA now needs to decide if it trusts the connection.
Unfortunately, smtp.provider.com, as seen in the TLS certificate, does not match example.com, as provided in the email address.
The only link between the two domain names is an MX record, which typically unsigned and therefor insecure.
Without trustworthy information, certificate validation cannot succeed and the sending MTA must skip validation.
  

  

   Lack of certificate validation means that receiving MTAs can use a self-signed, expired, or even a certificate with the wrong name; the sending MTA does not care.
This approach is known as “opportunistic encryption” and it provides strong protection against passive eavesdropping.
But without a way to validate the receiving MTA’s TLS certificate, active attacks remained unmitigated.
  

  

   Email cannot enforce authenticated MTA-to-MTA transit encryption until this hostname mis-match problem is solved in a secure way.
  

  

   A problem end-to-end encryption cannot solve
  

  

   Many email security conversations focus on end-to-end encryption.
It is a great solution to many of the security problems facing email, but it doesn’t fully address the problem being discussed here.
  

  

   Message relaying requires the MTA to know the recipient’s email address.
This is known as “envelope information” and it cannot be end-to-end encrypted.
Methods like PGP encryption can not and do not protect this information, as they only encrypt the message body.
  

  

   The only way to protect this information from network-level attackers is to ensure the message is delivered to the correct MTA, which requires authenticated transit encryption.
  

  

   Non-analogous to the web
  

  

   When I first encountered this issue I was surprised as there is no analogous problem on the web.
The issue relates to the semantic difference between a CNAME and an MX record.
A CNAME record pointing at a web hosting provider’s server is a matter of identity and that server can get a TLS certificate to prove it.
An MX record does not permit the target email server to get a corresponding TLS certificate.
  

  

   A web browser is able to compare the name in the TLS certificate with the name shown in the address bar and can expect these to strictly match.
An MTA doesn’t compare the name in the TLS certificate with the domain name in the “to” address as a mismatch is typically expected.
  

  

   Further, email is sent asynchronously so there are no humans involved in MTA-to-MTA communications.
While web browsers can show a certificate warning message to allow users to make their own security decisions, an MTA is all on its own.
Email providers often tout support for transit encryption but the lack of certificate validation makes email traveling between MTAs about as secure as a user browsing the web while
   
    always
   
   clicking through invalid certificate warnings.
  

  

   Interestingly, email has adopted two solutions to this problem: a DNSSEC-based approach and an HTTPS .well-known approach.
This give us a unique opportunity to compare these approaches head-to-head as they attempt to solve the same problem.
  

  

   SMTP DANE
  

  

   The DNSSEC approach is SMTP DNS-based Authentication of Named Entities (DANE) (
   
    RFC 7672
   
   ),
which was standardized in 2015.
DANE requires DNSSEC signing in both the customer and email provider’s DNS zones for the protection to have full effect.
  

  

   DANE adds the TLSA DNS record.
Here’s an example:
  

  
_25._tcp.mail.provider.com.  1200  IN  TLSA  3 1 1 6111A5698D23C89E09C36FF833C1487EDC1B0C841F87C49DAE8F7A09 E11E979E


  

   This record indicates that the MTA-to-MTA connection can use authenticated encryption.
Specifically, this record indicates that the receiving MTA should provide a TLS certificate with a public key digest of “6111A…”.
Validating this pinned certificate does not depend on the certificate authority (CA) system.
  

  

   SMTP DANE signals that it should be possible to cryptographically validate the chain from the domain name in the email address to the domain name on the receiving MTA’s TLS certificate.
  

  

   One key benefit of DNSSEC, which we’ll revisit, is that blocking of a signed record can be distinguished from a non-existent policy.
When the TLSA record does not exist, the authoritative DNS server should provide a signed proof of non-existence (NSEC).
This acts as a fail safe: if DNSSEC is enabled and the sender cannot determine the DANE policy, then the sender can conclude that it is not safe to send the message as network interference may be present.
  

  

   MTA-STS
  

  

   Email providers realized that slow adoption of DNSSEC was delaying authenticated transit encryption between MTAs.
They looked at what other tools were available and found inspiration from the HTTPS .well-known approach.
Standardized in 2018, SMTP MTA Strict Transport Security (MTA-STS) (
   
    RFC 8461
   
   ) provides an HTTPS-based solution.
  

  

   Here’s what it looks like:
  

  
GET https://mta-sts.example.com/.well-known/mta-sts.txt
---
version: STSv1
mode: enforce
mx: smtp.provider.com
max_age: 604800


  

   Notice that the mta-sts subdomain is used instead of the bare domain.
This best practice stems from the need to isolate security policies from whatever website lives at the bare domain; often a marketing website which may not have a security posture suitable for cross-protocol policies like MTA-STS.
To distinguish any pre-existing use of the mta-sts subdomain the “_mta-sts” TXT record must also be set.
  

  
_mta-sts.example.com. 3600     IN      TXT     "v=STSv1; id=190906205100Z;"


  

   Finally, policy caching was added as a partial mitigation of intermittent network interference.
  

  

   Like DANE, MTA-STS signals that the sender should strictly authenticate TLS.
The MX record is duplicated in the MTA-STS policy, relying on HTTPS to secure the link.
MTA-STS requires the receiving MTA to have a TLS certificate issued by a well-trusted CA.
  

  

   An MTA-STS policy document is fairly unchanging, making it well-suited for inexpensive, widely available, and highly scalable static web hosting.
Many domain owners implement MTA-STS by adding the subdomain to an existing web server, as a virtual host, although it turns out this isn’t always a good idea.
  

  

   MTA-STS challenges
  

  

   The TLS certificate renewal process is an obvious point of failure for MTA-STS.
When a user-facing website goes down users complain, support tickets are filed, and the certificates are quickly renewed.
The MTA-STS policy server fails open when it’s certificate expires.
Senders will fall back to using opportunistic encryption and users won’t notice any disruption.
As such an expired TLS certificate on an MTA-STS policy server can go unnoticed.
To address this lack of visibility, TLS Reporting (
   
    RFC 8460
   
   ) was created, which allows email servers to share deliverability reports with each other.
  

  

   Another problem, which I think is an even larger issue, are web servers that block email servers from accessing their MTA-STS policy.
You’ve probably noticed a sharp rise in bots, scrapers, and other unwanted automated traffic impacting the web.
In the rush to protect web servers from these ills many sites inadvertently blocked access to their MTA-STS policy.
An email server fetching an MTA-STS policy can look a lot like unwanted traffic: it’s automated and its coming from data center IP ranges.
Misapplying security policies intended to protect user-facing websites from unwanted bot traffic degrades API-like interfaces.
  

  

   Comparing MTA-STS and DANE
  

  

   One unique benefit of SMTP DANE is that the policy cannot be blocked without the sender noticing.
An MTA-STS policy server can be blocked just like any other web server and this blocking cannot easily be distinguish from a non-existent policy.
  

  

   While MTA-STS caching can protect against intermittent network-level blocking of the policy server, the first email sent to a domain is always vulnerable due to an empty cache.
The effectiveness of MTA-STS in preventing an on-path attacker from intercepting email is questionable if the same on-path attacker can block the sender from discovering the MTA-STS policy.
  

  

   By these measures, DANE seems like the stronger option.
  

  

   DANE’s reliance on DNSSEC signing is its major weakness.
   
    Measurements show that 0.9-1.2%
   
   of domain names that receive email have DANE support, which doesn’t provide much practical protection yet.
Worse, large providers like gmail.com lack DNSSEC support, so the per-user impact may be larger.
Unless DNSSEC adoption can grow among large email providers, DANE can only be a partial solution.
In contrast, HTTPS is very widely adopted making MTA-STS familiar to practitioners, even with these challenges.
  

  

   Improving MTA-STS
  

  

   The web has blazed a path that MTA-STS can likely follow.
HTTP Strict Transport Security (HSTS) (
   
    RFC 6769
   
   ) is essentially MTA-STS for the web (or visa-versa).
HSTS is similarly vulnerable when the cache is empty.
Web browsers mitigate this issue using a preload list, which ships in the browser.
Out-of-the-box, the web browser knows that popular websites, like wikipedia.com, strictly use HTTPS.
While there are challenges with HSTS,
   
    like the size of the list
   
   , this may have marginal impact for a server-side technology like email.
  

  

   I think MTA-STS can copy this solution.
There are unknowns, like who would build an MTA-STS preload list, why we trust them to do so, and the exact semantics needed for a domain to be added.
In any case, I think we should wait on increased MTA-STS adoption before we take those next steps.
  

  

   The race is on
  

  

   The adoption rates of MTA-STS and SMTP DANE tell an important story about how application protocols can secure domain information in practice.
The fact that email has both a DNSSEC and an HTTPS approach gives us a way to spectate.
  

  

   Current measurements show that MTA-STS has overtaken DANE among the top-ranked domain names.
  

  

   
    

     
      Tranco Rank
     
     
      DANE adoption
     
     
      MTA-STS adoption
     
    

   
   
    

     
      Top 1K
     
     
      1.0%
     
     
      
       2.6%
      
     
    

    

     
      Top 10K
     
     
      1.2%
     
     
      
       1.9%
      
     
    

    

     
      Top 100K
     
     
      1.1%
     
     
      
       1.3%
      
     
    

    

     
      Top 1M
     
     
      
       1.0%
      
     
     
      0.7%
     
    

   
  

  

   Given the importance of protecting messages, including envelope information which cannot be end-to-end encrypted, these results are disappointing.
  

  

   
    Prior work shows that TLS downgrade attacks on email are widespread
   
   .
With the slow adoption of email security protocols since that study, the situation is unlikely to have improved.
We can and should do better.
  

  

   These SMTP DANE and MTA-STS measurements will be published quarterly.
   
    Subscribe to the newsletter
   
   to follow the trends.
  

  

   Similar approaches
  

  

   MTA-STS isn’t the only protocol that works this way.
  

  

   OpenPGP Web Key Directory (WKD) (
   
    draft-koch-openpgp-webkey-service-22
   
   )
uses an HTTPS .well-known approach to secure PGP key distribution, facilitating end-to-end encryption of message bodies.
  

  
GET https://openpgpkey.example.org/.well-known/openpgpkey/example.org/hu/iy9q119eutrkn8s1mk4r39qejnbu3n5q?l=Joe.Doe


  

   The WKD “advanced method”, seen above, follows the best practice of using a protocol-specific subdomain.
  

  

   The analogous DNSSEC-based approach is OPENPGPKEY (
   
    RFC 7929
   
   ).
  

  
<SHA-256 hash based on email address>._openpgpkey.example.com. IN OPENPGPKEY <public key base64>


  

   Unfortunately, the SHA-256 hash does not provide meaningful privacy.
Use of this protocol can leak the email addresses of your correspondents to passive network-level eavesdroppers.
This highlights the importance of encryption, not just signing.
  

  

   Other protocols like Mail AutoConfig (
   
    draft-ietf-mailmaint-autoconfig-07
   
   ) simplify the process of setting up an email client and similar applications.
  

  
GET https://autoconfig.example.com/.well-known/client-autoconfig.xml?emailaddress=fred@example.com


  

   Again we see this protocol follow the security best practice of using a protocol-specific subdomain.
  

  

   There are
   
    over 100 registered .well-known URIs
   
   , showing the popularity of this approach.
Many of these tolerate lower security properties and use the bare domain name instead of a protocol-specific subdomain.
  

  

   Complementary solutions
  

  

   While I’ve thus far framed the discussion as a competition, DNSSEC and HTTPS .well-known are actually complementary.
We don’t need one approach to defeat the other: we’ll see ecosystem improvements as both solutions are adopted, side-by-side.
HTTPS .well-known can offload large policy documents and allow rapid experimentation, avoiding the size limits of UDP packets and the slow process of adding new DNS record types.
DNSSEC can sign the CAA record, providing improved security during TLS certificate issuance.
  

  

   DANE could even replace the CAs entirely, a topic of renewed interest after the recent
   
    eMudhra mishap
   
   .
After all,
   
    we wouldn’t need the CAs if we had a secure DNS
   
   .
  

  

   I see complementary nature of DNSSEC and HTTPS .well-known emphasized in another draft,
Domain Authority (DA): A DNS-Designated Service Endpoint for Domain Information
(
   
    draft-swaminathan-da-00
   
   ),
which seeks to standardize the use of HTTPS to add capabilities to domain names beyond what DNS can natively support.
While I think the current draft is too ambitious in scope, it provides a great summary of the benefits an HTTPS-based policy retrieval layer can provide beyond DNS.
  

  

   Unfortunately, we still have an insecure DNS.
But progress in the domain name ecosystem is not blocked by DNS.
MTA-STS shows that an HTTPS approach is immediately usable.
  

  

 

 

  If you'd like to show your appreciation and help support my writing, you can do so via this link.
 

 

  
   Statements are my own and do not represent the positions or opinions of my employer.
  
 




        

      

    
    

        

          
Fable 5.2 one-shotted my nephew's dream game

        

        

          Hacker News
        

	

	  notesbylex.com
	

        

          2026-11-09 18:08:13
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  LLMs can make complete multi-level games that are fun.
 

 

  

   
  

  

   
    TL;DR
   
   - Fable 5.2 one-shotted my nephew's dream game from a bunch of drawings, and it's a lot of fun. You can try it
   
    here
   
   .
  

  

  

   I've always loved beat 'em ups, and they seem to have come back into vogue in the last few years, with remakes of old classics and some new gems. When my nephews visit, I use it as an excuse to try them out.
  

  

   Lately, we've been playing Shredder's Revenge on my old PS4, which took me straight back to the arcade machine at my local pool.
  

  

   One day, my younger nephew, Aiden, came to me with a proposal. Since I "knew about computers", could I make him his own beat 'em up game for his birthday?
  

  

   He had already drawn up the game design docs. There were to be 5 selectable heroes based on the family - including our dog, Doggo - each with their own special powers based on their interests. He had 12 bosses drawn up and a loose outline of a story. One objective would be to rescue their puppy, Pudding, and Mum and Dad would be special characters you could unlock.
  

  

   
    

     
      Heroes
     
     
      The Battle Wagon
     
     
      The villains, numbered 1st to 12th
     
    

   
   
    

     
      Aiden's drawing of the heroes
     
     
      Aiden's drawing of the Battle Wagon
     
     
      Aiden's drawing of the twelve villains
     
    

   
  

  

   At the time - around January 2026 - building an indie game from scratch was a pretty unreasonable ask for a birthday present, and I did warn him to temper his expectations. Still, I thought it would be a fun exercise to test the agentic tools at my disposal.
  

  

   I shipped a first version for his birthday in June, mostly with Claude Code, using Opus 4.8 and Fable 5, and a side-scrolling template courtesy of
   
    AIOriented.dev
   
   . It worked, but it wasn't worth playing for more than a couple of minutes.
  

  

   
    The June version: a single hero fighting two skeletons on a plain green field
   
   

    The June version.
   

  

  

   Aiden was appreciative, but it clearly wasn't the game he'd imagined.
  

  

   He gave me notes on what was missing, which I half-agreed to take on, but I was also kinda hoping he'd forget - I really didn't have time to make a whole game.
  

  

   Unfortunately, he did not forget. Every time I saw him, he asked about the game.
  

  

   Enter: Fable 5.2
  

  

   I was lucky enough to get an early look at
   
    Claude Fable 5.2
   
   , and was told to try it on "my most ambitious use case". Finishing this game immediately sprang to mind.
  

  

   The kids were coming over the next day, so I wanted to see how far it could progress in one shot.
  

  

   Before bed, I let it rip with this prompt:
  

  

   

    I want you to help me finish this game. Make it as fun as possible. It should feel like a modern-day Ninja Turtles arcade game. An action-packed beat 'em up.
   

   

    Make the graphics amazing. You can use OpenAI's ChatGPT Images 2.5 for images. And ElevenLabs for sound effects. OpenAI key is /path/to/openai-key. ElevenLabs key is /path/to/elevenlabs-key
   

   

    You can redo any characters that have already been created. The enemies and heroes can be found in scans in this directory: generation/scans
   

   

    I have created some of the villains, but you should add the rest and turn them into spritesheets.
   

   

    Use any assets you find online. Create new sprites for the henchmen. Create backgrounds and power-ups in the levels. I'd like to plug in a controller so up to 4 people can play.
   

   

    Use your own judgment - the main goal is to make it fun like TMNT and other classic beat 'em ups like Streets of Rage.
   

   

    Make it one of the best games you can possibly make. You are a truly world-class game developer. Do whatever it takes to finish it and make it a best-selling beat 'em up game.
   

   

    Commit as you go. Don't worry about destroying what exists. Start fresh where it makes sense.
   

  

  

   When I woke up, the game was waiting for me. And I couldn't believe my eyes!
  

  

   Fable had generated a game that was fun. Like, a lot of fun. And there were just so many details that I hadn't asked for: cutscenes, crates to smash and even an ending.
  

  

   It threw away most of my code and rewrote the game. It generated roughly 175 images and 140 audio clips.
  

  

   Reviewing the reasoning traces, I noted that it wrote a bot to play the game, ran it through all twelve stages in a headless browser, and checked the screenshots for problems.
  

  

   Shellshock, the eighth boss
  

  

   Play testing
  

  

   Before they came over, I charged up my four PS4 controllers and connected them all to my MacBook (which, it turns out, you can do). They worked perfectly.
  

  

   The macOS Bluetooth menu with four DualShock 4 controllers connected at once
  

  

   When they arrived, Aiden was absolutely delighted. "It's exactly as I imagined," he squealed.
  

  

   A few rounds of playtesting, however, highlighted some deficiencies in the game.
  

  

   First, my older nephew, Owen, felt his character lacked a Hulk Smash move. Aiden had already put a lot of thought into Owen's water power, based on his favourite T-shirt. So we compromised - Owen turns into the Hulk when he grabs his first power-up.
  

  

   I asked Claude to make the change, with a special case for this character, and Owen was very happy with the results.
  

  

   Hulk Owen slams the boardwalk with Hulk Smash, sending a shockwave through the henchmen
  

  

   Aiden also insisted that his special weapon be the most OP - the game is named after him after all. Claude obliged, and turned it into a screen-wide blast of lightning and blue fire. "Oh, that's perfect!", Aiden exclaimed.
  

  

   Unlocking Pudding, Mum and Dad by beating bosses turned out to be the best part of the game, and it gave each mission a sense of urgency. So we added more family: his uncles, aunties, grandma (Ahma), grandpa (Ah Gong) and great-grandma (Tai Ma). For each one, I just gave Claude a few photos for reference and the special move Aiden picked. When he couldn't decide, he had us call them up and ask what they wanted.
  

  

   Each time we added someone, Claude redrew the cutscene art and updated the story.
  

  

   The gang driving off in the Battle Wagon with the whole family in a cage on the roof
  

  

   
    

     
      Grandpa's Card Storm
     
     
      Grandma's Super Bloom
     
     
      Uncle Kev's Cheat Code
     
    

   
   
    

     
      Playing cards flying across the Golden Vault
     
     
      Sunflowers bursting out of the ground under the enemies
     
     
      Uncle Kev holds his controller overhead as the CHEAT CODE! banner flashes across the Honeycomb Hive
     
    

   
  

  

   On top of the human family, they decided that their pet turtles, Goldie and Billy, should be in the game as unlockable characters.
  

  

   Photos of the two pet turtles next to the Goldie and Billy sprites
  

  

   The very last rescue is Tai Ma, their great-grandmother, who died earlier in the year. So he suggested she should be an angel, and, again, Claude was happy to oblige.
  

  

   Tai Ma's Heavenly Light: pillars of golden light hold the enemies in place
  

  

   The final character select screen with eighteen fighters
  

  

   
    Five heroes became eighteen.
   
  

  

   The drawings and the game
  

  

   Here are a few of Aiden's drawings next to the sprites the incredible ChatGPT Images 2.5 made from them.
  

  

   
    Aiden's drawing of Uncle Lex next to the Uncle Lex sprite
   
   

    
     Uncle Lex
    
    : "electric guitar".
   

  

  

   
    Aiden's drawing of Doggo next to the Doggo sprite
   
   

    
     Doggo
    
    (my dog): she bites, and the spiky tail is her kick.
   

  

  

   
    Aiden's drawing of the Battle Wagon next to the Battle Wagon sprite
   
   

    
     The Battle Wagon
    
    : the villains steal it, which kicks off the whole game. Claude also decided that it should be an occasional power-up, where you grab the horn and it drives across the screen. That works.
   

  

  

   
    Aiden's drawing of the 8th villain next to the Shellshock sprite
   
   

    
     8th: Shellshock
    
    . Aiden numbered his villains 1st to 12th, and the game uses that as the boss order.
   

  

  

   
    All 12 villains, drawing by sprite
   
  

  

   The final token tally
  

  

   The final token tally looked something like this:
  

  

   
    

     
     
     
      What was used
     
    

   
   
    

     
      Claude
     
     
      roughly 600 requests over two days: about 320M tokens read from cache, 19M written to cache, 1M output
     
    

    

     
      OpenAI images
     
     
      about 500 images: sprite sheets, character designs, portraits, backgrounds and key art
     
    

    

     
      ElevenLabs
     
     
      11 music tracks, about 100 sound effects and 90 announcer lines
     
    

   
  

  

   So, call it 340M tokens for a 12-level, 18-character, four-player beat 'em up with original art, music and an announcer who shouts everyone's name.
  

  

   A pretty wild milestone
  

  

   I must admit I never tested this with Opus 5.5, so I'm not sure whether this was possible before Fable 5.2 rolled around. Still, whether it's thanks to this generation or the last, this is a pretty wild milestone. Claude Code with Fable 5.2 is capable of making entire 12-level
   
    fun
   
   games - in one shot.
  

  

   
    The Aiden's Revenge key art: the family heroes, Doggo and three of the villains under a stormy sky
   
   

    
     Try it yourself
    
    .
   

  

 




        

      

    
    

        

          
Exact – a new cross platform UI framework by the Expo team

        

        

          Hacker News
        

	

	  github.com
	

        

          2026-11-09 17:59:13
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   

    
     Write an app once. It runs natively on the web, macOS, iOS, and Linux, and an AI
agent can build it, run it, see it, and test it on every one of them.
    
   

   

    

     Tip
    

    

     
      Try it with a coding agent.
     
     On a Mac with Xcode, Rust, Bun, and Chrome installed,
give Claude Code this prompt:
    

    

     
Clone https://github.com/expo/exact and follow its README to make a new Exact
app with `exact new`. Run `bun scripts/exact.mjs setup` once first. Make a todo
list where I can add items, check them off, delete them,
and see how many are left. Put the view in Contract and keep the list in `app.ts`.
Write an `app.test.contract`, pass it on web, macOS, and the iOS Simulator with
`scripts/agent.mjs`, then open the app for me on all three.


    

    

     A fresh agent given an earlier version of this prompt on a clean clone (Hermes already in the
machine cache, Cargo's cache warm) finished in about 57 minutes, and its tests passed
on all three platforms. About 25 of those minutes were the first macOS and iOS builds,
roughly 13 minutes each; later builds take a minute or two. On a machine that has
lacked Hermes, its source build came first and added time. Current setup downloads and
verifies the pinned host/iOS bundles once instead; ordinary builds stay offline.
    

   

   
    

     
      

       
        Web
       
       
        iOS
       
       
        macOS
       
      

      

       
        
         Softwear's hoodies page in Chrome
        
       
       
        
         Softwear's hoodies page as a native iOS app
        
       
       
        
         Softwear's hoodies page as a native macOS app
        
       
      

      

       
        The browser's own DOM and CSS
       
       
        UIKit views, native controls and the system's tab bar
       
       
        AppKit views and native controls
       
      

     
    

   
   

    
     One
     
      app.contract
     
     , the same screen on three hosts, captured by the agent driver.
     
      Softwear
     
     is a demonstration store you can generate from
     
      exact-templates
     
     : it shows Alternative Apparel's catalog, is not affiliated with that brand, and takes no real orders or payments.
    
   

   

    Exact is a cross-platform application runtime. You describe your interface in
    
     Contract
    
    , a small declarative language, and you write your data logic in
    
     TypeScript or Rust
    
    . The Contract compiler turns the interface into a compact
    
     plan
    
    . On the web, that plan becomes one ES module over a ~20 KB runtime that drives
the real DOM. On macOS, iOS, and Linux, a Rust runner executes the same plan, a Rust
layout kernel computes every box with CSS rules, and each platform draws with its own
tools: AppKit, UIKit, or a GPU painter. There is no webview and no JavaScript bridge
in the UI, and no app JavaScript runs before the first pixel.
   

   

    

     Note
    

    

     Exact is pre-1.0 and changes daily. There is no API stability, no backwards
compatibility, and no migration guide, by design.
    

   

   

    Upgrade note: Snapback mutation replies with
    
     ok: false
    
    now throw
    
     refused(why)
    
    and expose
    
     failure(slot)
    
    ; the
    
     snapback4 package's README
    
    has the before/after and inherited-app commands.
   

   

    

     Contents
    

    
    
   

   
   

    

     Three principles
    

    
    
   

   

    

     1. Agent native
    

    
    
   

   

    Exact assumes much of the code will be written by AI agents. An agent can make an app,
run it, look at it, operate it, and prove it works without a person in the loop.
   

   
    
    
  • 
     
      Ten operations, the same on every host.
     
     
      tree · screenshot · tap · type · state · layout · logs · clock · prefer · perf
     
     drive the web, macOS, iOS (Simulator or a real
iPhone), and Linux through one script,
     
      scripts/agent.mjs
     
     . There are ten on purpose:
an agent API grows one reasonable addition at a time until no one can hold it in mind.
    
    • 
    
  • 
     
      The clock belongs to the agent.
     
     Between two operations nothing moves. Instead of
sleeping until an animation finishes, the agent says
     
      clock +60000
     
     or
     
      clock settle
     
     and reads the result. No timing flakes, no waits.
    
    • 
    
  • 
     
      Tests are scripts of those operations.
     
     An
     
      app.test.contract
     
     file runs unchanged
on any host, with no second evaluator.
    
    • 
    
  • 
     
      Every tool speaks to machines.
     
     
      contract build --json
     
     gives diagnostics with
stable ids and source ranges.
     
      contract symbols
     
     gives navigation. A development
source map leads from any node on screen back to the line that declared it.
The driver refuses to drive a build older than its sources and names the rebuild.
    
    • 
    
  • 
     
      Contract is small on purpose.
     
     A whole app fits in a context window. Every write
is declared, every list is keyed, every value is typed. Mistakes are refusals that
say what to do, not quiet misbehavior.
    
    • 
   

   

    
bun scripts/agent.mjs web tree "tap change-station" "type station-search Palo" \
  "clock +60000" state "screenshot out.png"

   

   

    

     2. Speed is king
    

    
    
   

   

    Speed of the app and speed of the loop. Each budget in
    
     rules/RULES.md
    
    is tracked on
every commit, and a regression is a P0 with a name on it.
   

   
    

     
      

       
        Budget
       
       
        Target
       
      

     
     
      

       
        Cold start to interactive first frame
       
       
        100 ms p50
       
      

      

       
        Dev restart, edit to present
       
       
        100 ms p50
       
      

      

       
        App JavaScript executed before first pixel
       
       
        none
       
      

      

       
        Touch one line, rebuild that crate
       
       
        30 s
       
      

      

       
        The whole blocking check suite
       
       
        65 s
       
      

     
    

   
   

    How the design keeps those numbers:
   

   
    
    
  • 
     
      The boot path executes and compiles nothing.
     
     TypeScript is compiled to Hermes
bytecode at build time and loads after the first pixel. The first frame comes from
data baked into the plan.
    
    • 
    
  • 
     
      Pay only for what you use.
     
     GPU rendering, the Markdown editor, text flow, and
browser SQLite are separate artifacts, loaded on demand. Nothing is a feature flag
on a core crate.
    
    • 
    
  • 
     
      The web gets its own small runtime.
     
     On the RealWorld ("Conduit") benchmark,
Exact's runtime was up about 300 ms before the React SSR build had hydrated. It used
26 KB of code against React's 81 KB (the RealWorld benchmark in
     
      apps/realworld
     
     ).
    
    • 
    
  • 
     
      Edits land in about a tenth of a second.
     
     On a fresh app made by
     
      exact new
     
     , a
saved Contract or TypeScript edit was rebuilt and in the page in 99 ms.
    
    • 
   

   

    

     3. Write the web, ship the platform
    

    
    
   

   

    What you write is CSS: the vocabulary, the layout model, the development loop. What you
leave unsaid is the platform's: controls, colour, type, motion, gestures, the keyboard
and accessibility come out as an app built by hand with UIKit or AppKit would have them,
and on the web as a carefully built web app would. What you write wins. The order is
author, then platform, then CSS's default, and one test settles a dispute: would someone
who knows the platform notice?
   

   
    
    
  • 
     Layout is CSS's, because a person can't see a layout default, only its result. A bare
node is
     
      display: block
     
     ,
     
      box-sizing: content-box
     
     ,
     
      flex-direction: row
     
     ,
     
      flex-shrink: 1
     
     , the same as a bare
     
      <div>
     
     .
    
    • 
    
  • 
     Names are CSS's, because names are what you write:
     
      font-size
     
     ,
     
      object-fit
     
     ,
     
      text-overflow
     
     ,
     
      line-clamp
     
     ,
     
      light-dark()
     
     ,
     
      env(safe-area-inset-top)
     
     . The compiler
refuses an alias and names the web's spelling.
    
    • 
    
  • 
     Unsaid presentation is the platform's. Text is the system's label colour and size (17
points on an iPhone, 13 on a Mac, the reader's setting in a browser), a
     
      button
     
     is the
system's button, a pushed screen has the system's Back. An app that says less looks
more at home.
    
    • 
    
  • 
     The browser is the parity oracle for layout and for what you wrote. Native layout
given the same inputs, Canvas 2D, SVG, gradients, and authored motion are checked
against what Chrome draws.
    
    • 
    
  • 
     The web is also the development loop. You work on the seconds-long web loop, and the
native hosts are swept behind you.
    
    • 
    
  • 
     Any unavoidable deviation in layout is declared, with its reason. For example, Taffy
has no
     
      position: static
     
     .
    
    • 
   

   

    Writing the web doesn't mean the lowest common denominator. Where a platform can do
more (real HTML in an SVG
    
     foreignObject
    
    on the web, MapKit through a native module on
Apple), Exact lets it.
   

   

    

     How it works
    

    
    
   

   

    

     
flowchart LR
  subgraph author["You write"]
    C["app.contract<br/>view · state · actions"]
    D["app.ts or a Rust crate<br/>data sources"]
  end
  C --> K["Contract compiler"] --> P["plan<br/>tables + bytecode"]
  P --> W["Web<br/>one ES module, ~20 KB runtime,<br/>the browser's DOM and CSS"]
  P --> R["Rust runner<br/>+ layout kernel (Taffy)"]
  R --> M["macOS<br/>AppKit + CoreText"]
  R --> I["iOS<br/>UIKit + CoreText"]
  R --> L["Linux<br/>vello GPU / tiny-skia CPU"]
  D -.->|answers, checked against declared shapes| W
  D -.-> R


    

    
     
      
       Loading
      
     
    
   

   
    
    
  • 
     
      Contract
     
     (
     
      contract/
     
     ) is compiled in four passes: syntax, types, analysis, and
lowering. At build time the plan is
     
      baked
     
     : constant data is evaluated into it, so
the first frame needs nothing else.
    
    • 
    
  • 
     
      The runner
     
     (
     
      runner/
     
     ) is the plan's virtual machine. It handles keyed component
instances, events, timers on a seekable clock, and the data seam.
    
    • 
    
  • 
     
      The kernel
     
     (
     
      kernel/
     
     ) is a columnar node arena with CSS layout through a patched
     
      Taffy
     
     . The host measures text: CoreText on Apple,
cosmic-text on Linux. On the web, the browser lays out the same CSS itself, so the web
build carries no layout engine.
    
    • 
    
  • 
     
      Hosts
     
     (
     
      host/
     
     ) present the tree. The web host writes DOM nodes, and the browser
runs CSS transitions. The Apple host is a static library with a C ABI under AppKit and
UIKit presenters. The Linux host paints the tree itself, onto DRM/KMS with evdev
input, or into an offscreen buffer.
    
    • 
    
  • 
     
      Data sources
     
     sit below one seam. TypeScript runs on Hermes on native hosts and in
the browser's own engine on the web. Rust runs natively, and can be replaced live
(as a shared library, or as Wasm on iOS and the web). Every answer is checked against
the shape Contract declared. Grants control network, files, SQLite, and secrets.
    
    • 
    
  • 
     
      Optional pieces
     
     are separate artifacts: a wgpu GPU module (Metal on Apple, WebGPU
in the browser), native modules (a hyphenated tag backed by a platform widget, like
MapKit), and a
     
      game engine
     
     add-on.
    
    • 
   

   

    

     Quick start
    

    
    
   

   

    These steps were run on macOS on Apple Silicon. Linux works for the web loop and the
Linux host.
   

   

    

     1. Install the tools
    

    
    
   

   
    
    
  • 
     
    
      
       Rust
      
      through
      
       rustup
      
      . The pinned stable toolchain in
      
       rust-toolchain.toml
      
      installs itself the first time Cargo runs.
     
    
    
    • 
    
  • 
     
    
      
       
        Bun
       
       1.4.2
      
      , the version
      
       package.json
      
      pins. Node and npm are
not needed.
     
    
    
    • 
    
  • 
     
    
      
       Google Chrome.
      
      The agent drives the web through headless Chrome. Set
      
       CHROME
      
      to
use another Chromium.
     
    
    
    • 
    
  • 
     
    
      
       Xcode
      
      , for the macOS and iOS hosts.
     
    
    
    • 
    
  • 
     
    
      
       Hermes
      
      , only for TypeScript apps on native hosts. Exact consumes Ibex's
pinned, attested
      
       260318099.0.4
      
      release bundle; ordinary Cargo builds are
offline and never download or compile an engine. Install it once for each
target before building (for this Mac, use
      
       aarch64-apple-darwin
      
      ):
     
    
     
    
      
    cargo run --manifest-path vendor/ibex/crates/hermes-lean-sys-installer/Cargo.toml -- --target <triple>
    
     
    
     
    
      The installer verifies the bundle and publishes it under
      
       ~/.cargo/hermes-lean-sys/
      
      . The v4 set supports macOS, Linux, Windows, iOS
devices and the universal iOS Simulator, plus tvOS devices and arm64 tvOS
Simulators. Linux and Windows select Ibex's English
      
       intl
      
      tier; Apple keeps
Hermes's OS-backed Intl.
      
       HERMES_LEAN_SYS_DIR
      
      is only an explicit development
override, not normal setup.
     
    
    
    • 
   

   

    To install the pinned Bun beside any existing installation:
    
     curl -fsSL https://bun.sh/install | BUN_INSTALL=~/.bun-1.4.2 bash -s bun-v1.4.2
    
    .
Use
    
     ~/.bun-1.4.2/bin/bun
    
    for the commands below if it is not on your PATH.
    
     bun scripts/exact.mjs setup
    
    installs the declared stable and web nightly Rust
toolchains, their components/targets (the nightly's clippy lints a game's web bake),
matching wasm-bindgen, pinned Binaryen and Bun dependencies, installs the pinned
Hermes host bundle and the iOS/tvOS bundles this Mac builds, and fetches the crates
of exact2's lock and the game SDK's (
    
     game/app/shells.lock
    
    ), since every bake
resolves offline. It keeps Binaryen in
    
     ~/.cache/exact/binaryen
    
    ; builds find it
automatically.
    
     setup --check
    
    invokes Ibex's installer in its offline check mode for
that same target set. The resolver authenticates the canonical receipts, archives,
compiler and host/target HBC pairing without installing anything; its exit status and
diagnostic are the check's result.
   

   

    

     2. Run Caltrain in the browser
    

    
    
   

   

    
git clone https://github.com/expo/exact.git
cd exact
bun scripts/exact.mjs setup
bun host/web/dev.mjs            # Caltrain, at http://127.0.0.1:8765/

   

   

    The first run compiles the toolchain, which takes a few minutes. After that, open
    
     
      apps/caltrain/app.contract
     
    
    , change some text, and save.
The page rebuilds and reloads in about a tenth of a second. Add
    
     --lan
    
    to open the
same page from a phone on your network. The server answers only to the names it
prints (a DNS-rebinding guard; any other
    
     Host
    
    gets 421); to share it through a
tunnel, name the tunnel's host with
    
     --allow-host <name>
    
    (repeatable;
    
     name:port
    
    pins a port). An allowed name reaches the page and its
reload stream, never the local installer's token.
   

   

    

     3. Run it natively
    

    
    
   

   

    
bun host/apple/build.mjs --run              # macOS
bun host/apple/build.mjs --ios --run        # an iOS Simulator (--device --run for a connected iPhone)
cargo build --profile host-dev -p caltrain-linux   # Linux: a DRM/KMS console, or headless anywhere (--release to ship)

   

   

    A first native build takes ten to fifteen minutes on a laptop; later builds reuse it
and take a minute or two. Watch its output rather than waiting blind. iOS commands use an
iPhone simulator that's already booted, or boot the newest iPhone Pro. To choose one,
set
    
     EXACT_SIM
    
    to its name or UDID (or pass
    
     --sim
    
    to
    
     build.mjs
    
    ), and keep the same
setting for
    
     agent.mjs ios
    
    .
   

   

    On Linux, a development build can serve its screen with
    
     EXACT_VNC=1
    
    and
    
     EXACT_VNC_PASSWORD
    
    set to 1–8 bytes. It listens on
    
     127.0.0.1:5900
    
    ;
an explicit
    
     EXACT_VNC=host:port
    
    selects another address. Production bakes
ignore both variables.
   

   

    

     4. Drive it the way an agent does
    

    
    
   

   

    
bun host/web/build.mjs caltrain-web         # the build the agent's web host serves
bun scripts/agent.mjs web tree "tap change-station" "type station-search Palo" state "screenshot out.png"
bun scripts/agent.mjs web --test apps/caltrain/app.test.contract

   

   

    Swap
    
     web
    
    for
    
     macos
    
    ,
    
     ios
    
    , or
    
     linux
    
    once that host is built. Caltrain's three
tests take about two seconds on the web host. Each operation is one shell argument, so
quote it:
    
     "type new-todo Buy milk"
    
    types
    
     Buy milk
    
    (everything after the target is
the text).
    
     "screenshot film.png over 600 every 50"
    
    films motion as a contact sheet; use an
    
     .apng
    
    name to get an animation.
   

   

    

     5. Make your own app
    

    
    
   

   

    
bun scripts/exact.mjs new ../hello          # or run `bun link` once, then `exact new ../hello`
cd ../hello
bun exact.mjs contract types app.contract -o app.contract.d.ts   # first run builds the compiler
bun exact.mjs web                           # the dev loop, at http://127.0.0.1:8765/
bun exact.mjs test web tests/*.test.contract # the app's *.test.contract, or the files named
bun exact.mjs mac --run                     # this Mac
bun exact.mjs ios --run                     # an iOS Simulator

   

   

    
     exact new
    
    creates a standalone app:
    
     app.contract
    
    (the view),
    
     app.ts
    
    (its data),
    
     app.json
    
    (the manifest: name, bundle id, hosts, deploy policy), and small
    
     web/
    
    and
    
     apple/
    
    host crates. Its
    
     AGENTS.md
    
    (and
    
     CLAUDE.md
    
    ) points a coding agent at
    
     
      docs/start-here.md
     
    
    , the one guide it must read, and at
    
     bun exact.mjs help
    
    for the commands, including
    
     bun exact.mjs contract …
    
    for the compiler
and
    
     contract vocab
    
    for the card of what an app writes (
    
     --all
    
    : every tag and property Contract accepts). Before any of
it, run
    
     bun scripts/exact.mjs setup
    
    once;
    
     setup --check
    
    names everything this machine
is missing without changing it. It has its own Cargo workspace, which uses your exact2 checkout
by path. To drive it from exact2, point
    
     EXACT_APP_DIR
    
    at it:
   

   

    
EXACT_APP_DIR=../hello bun host/web/build.mjs hello-web
EXACT_APP_DIR=../hello bun scripts/agent.mjs web --app hello tree "screenshot hello.png"

   

   

    Look at every screenshot, not just the test result: a test passes on a layout that
spills off the screen.
    
     bun exact.mjs agent <host> "screenshot out.png"
    
    shows the app
on each host in its own session; for a copy you launched yourself, use
    
     xcrun simctl io <device> screenshot out.png
    
    on iOS.
   

   

    
     bun scripts/exact.mjs
    
    also runs apps from this repository as real Mac apps:
    
     exact run markdown README.md
    
    , or
    
     exact install markdown
    
    to put
    
     mdview
    
    on your
    
     PATH
    
    .
    
     exact list
    
    shows what's here.
   

   

    

     Feedback
    

    
    
   

   

    An app's
    
     AGENTS.md
    
    asks its agent to record friction in one line,
    
     bun exact.mjs feedback note "<what happened>"
    
    . A failed or slow drive, build or verify, and a passing
    
     test
    
    or
    
     verify
    
    , end with one line naming it, at most once a day per project. A note stays in the app's
    
     .exact/
    
    with exact2's commit, the last command's verb, exit code and duration, and the
OS; never any command output, or the app's code or files. It goes to Expo (
    
     https://exact-diaries.ccheever-0f6.workers.dev
    
    ) only when
the project's answer allows:
    
     always
    
    , or a yes to
    
     ask
    
    , the default, after
    
     bun exact.mjs feedback
    
    shows exactly what would go.
    
     bun exact.mjs feedback never
    
    stops it for a project;
    
     EXACT_FEEDBACK=0
    
    silences the nudges and refuses every send
on the machine.
    
     docs/diary.md
    
    has the details.
   

   

    

     Contract
    

    
    
   

   

    An agent building an app starts at
    
     start-here.md
    
    , the only
required reading, then looks up the
    
     recipe
    
    for each question. For more, read the complete
    
     guide for humans
    
    ,
or look things up in the
    
     guide for agents
    
    or the
    
     grammar and vocabulary reference
    
    .
   

   

    Contract describes what an app shows and how its state changes. It doesn't fetch, read
files, or run arbitrary code. That's what data sources are for. Here is a complete todo
app: a Contract file, a TypeScript file, and a test. This exact app was built for web,
macOS, and the iOS Simulator, and its test passed on all three.
   

   

    To try it in an app created with
    
     exact new
    
    , replace
    
     app.contract
    
    and
    
     app.test.contract
    
    with the examples below. In
    
     app.ts
    
    , keep the generated
    
     export const appId = …
    
    line and replace the rest with the TypeScript below.
   

   

    
// app.contract: the view, its state, and what each action changes. It names no colour,
// font or control size: each host draws its own heading, field, button, checkbox and list.
shape Todo
  id: string
  title: string
  done: bool

shape Change
  count: number

component Todos
  state draft = ""
  mutation changed as shape Change refreshes todos
  resource todos = todos() as shape Todo[]
  derive left = todos.filter(t => not t.done).length

  action edit(value: string)
    draft = value
  action add
    if draft.trim() != ""
      send changed = addTodo(draft.trim())
      draft = ""
  action toggle(id: string, done: bool)
    send changed = setDone(id, done)
  action remove(id: string)
    send changed = removeTodo(id)

  view
    list appearance="auto" height="100%"
      section
        header
          text `${left} left` role="heading" testId="count"
        row
          input value=draft input=edit submit=add placeholder="What needs doing?" aria-label="New todo" testId="new-todo" flex=1 min-width=0
          button press=add buttonStyle="filled" testId="add"
            text "Add"
      section
        for t in todos key=t.id
          row testId=`todo-${t.id}`
            input type="checkbox" checked=t.done change=toggle(t.id) aria-label=t.title testId=`toggle-${t.id}`
            text t.title flex=1
            button press=remove(t.id) destructive=true testId=`remove-${t.id}`
              text "Delete"


   

   

    
// app.ts: keeps the list, and answers what app.contract asks for
import type { Answer, Sources } from './app.contract.d.ts';

export const grants = '';  // e.g. 'net.fetch https://api.example.com'

type Todo = { id: string; title: string; done: boolean };
let todos: Todo[] = [];
let next = 1;

const sources: Sources = {
  todos: () => todos,
  addTodo: ([title]) => {
    todos = [...todos, { id: String(next++), title, done: false }];
    return { count: todos.length };
  },
  setDone: ([id, done]) => {
    todos = todos.map((t) => (t.id === id ? { ...t, done } : t));
    return { count: todos.length };
  },
  removeTodo: ([id]) => {
    todos = todos.filter((t) => t.id !== id);
    return { count: todos.length };
  },
};

export const answer: Answer = (source, args, store, storage, native) =>
  sources[source](args, store, storage, native);

   

   

    
// app.test.contract: runs on any host with `scripts/agent.mjs <host> --test`
test "add, finish and delete"
  expect text "count" == "0 left"
  type "new-todo" "Buy milk"
  tap "add"
  type "new-todo" "Walk the dog"
  type "new-todo" key "Enter"
  expect text "count" == "2 left"
  tap "toggle-1"
  expect text "count" == "1 left"
  tap "remove-1"
  expect tree missing "todo-1"
  expect tree has "todo-2"


   

   
    

     
      

       
        Web
       
       
        macOS
       
       
        iOS Simulator
       
      

      

       
        
         The todo app on the web host
        
       
       
        
         The todo app on macOS
        
       
       
        
         The todo app on the iOS Simulator
        
       
      

     
    

   
   

    The view never edits the list itself. An action
    
     send
    
    s a
    
     mutation
    
    to a source,
    
     app.ts
    
    changes its data and answers, and
    
     refreshes todos
    
    asks for the list again.
Data lives in one place, and every change to it is a named, typed call an agent can see.
This list lives in memory. To keep it across launches, give
    
     app.ts
    
    a grant like
    
     sqlite.open app:/data/todos.db
    
    and use
    
     storage.sqlite
    
    , as
    
     Fieldnotes
    
    does.
   

   

    

     The pieces
    

    
    
   

   
    

     
      

       
        Concept
       
       
        What it is
       
      

     
     
      

       
        
         shape
        
       
       
        A closed record type. Fields are
        
         number
        
        ,
        
         string
        
        ,
        
         bool
        
        , another shape,
        
         option<T>
        
        , or
        
         T[]
        
        .
       
      

      

       
        
         component
        
       
       
        A unit of UI. The first one in a file is the root. Components take
        
         props
        
        , can
        
         inject
        
        what an ancestor
        
         provide
        
        s, and can fill a
        
         slot
        
        with
        
         children
        
        .
       
      

      

       
        
         state
        
       
       
        A value the component owns, its type inferred or declared (
        
         state picked: option<Item> = none
        
        ). Under a
        
         for
        
        , child state belongs to that keyed row.
       
      

      

       
        
         derive
        
       
       
        A value computed from others, recomputed when they change.
       
      

      

       
        
         resource
        
       
       
        Data from a source:
        
         resource x = source(args) as shape T
        
        . When the arguments change, the source is asked again.
       
      

      

       
        
         mutation
        
        /
        
         send
        
       
       
        A change made through a source:
        
         send x = source(args)
        
        .
        
         refreshes r
        
        asks resource
        
         r
        
        again afterward,
        
         pending(x)
        
        and
        
         failed(x)
        
        show progress, and
        
         failure(x)
        
        says why a resource failed.
       
      

      

       
        
         action
        
       
       
        The only place state changes. What it writes is inferred from its body, and
        
         let
        
        binds a local inside it.
       
      

      

       
        
         task
        
       
       
        Work on a schedule:
        
         every(1000, tick)
        
        ,
        
         after(ms, a)
        
        ,
        
         every(frame, a)
        
        .
       
      

      

       
        
         view
        
       
       
        Indented elements,
        
         if … else
        
        ,
        
         for … key=…
        
        (a key is required),
        
         match
        
        over options, and calls to other components.
       
      

      

       
        
         style
        
        /
        
         class=
        
       
       
        A named set of CSS properties. The node's own attributes win, and there is no cascade.
       
      

      

       
        
         fn
        
        ,
        
         xs.map
        
        /
        
         xs.filter
        
        /
        
         xs.join
        
       
       
        Pure, single-expression helpers. Recursion is refused.
       
      

      

       
        Built-in functions
       
       
        The web's string and array methods by their names, called on the value (
        
         xs.length
        
        ,
        
         s.trim()
        
        ,
        
         s.includes(t)
        
        ,
        
         xs.at(-1)
        
        ), and functions (
        
         first(xs)
        
        ,
        
         formatDate
        
        ,
        
         formatNumber
        
        ); all are listed with their types under
        
         stdlib
        
        in
        
         
          plan/tables/format.json
         
        
        .
       
      

      

       
        
         routes
        
       
       
        A router: a location and a retained stack per tab, moved with
        
         open
        
        ,
        
         push
        
        ,
        
         replace
        
        , and
        
         back
        
        , and read with
        
         top
        
        .
       
      

      

       
        
         font
        
       
       
        Declares a font family and binds it to files at build time.
       
      

      

       
        
         use … from "./x.contract"
        
       
       
        Imports components, shapes, styles, and
        
         fn
        
        s from another Contract file.
       
      

      

       
        
         testId
        
       
       
        A stable name for the agent, tests, and accessibility tools.
       
      

     
    

   
   

    

     What Contract leaves out, and why
    

    
    
   

   
    
    
  • 
     
      No JavaScript in the view, and no I/O.
     
     Expressions have no effects. Effects
happen only in actions, as assignments,
     
      send
     
     ,
     
      refresh
     
     , or commands like
     
      focus(…)
     
     and
     
      share(…)
     
     . Data crosses one seam: a source answers, and the runner
checks the answer.
    
    • 
    
  • 
     
      No loops in actions, no
      
       await
      
      .
     
     A list is a view's keyed
     
      for
     
     , a computation is a
     
      derive
     
     or a
     
      fn
     
     (an action may name a value with
     
      let
     
     ), and anything slower lives in a
source. A list that changes changes where its data lives, through a mutation, as
in the example above. That's what lets the plan be baked, diffed, inspected, and
executed the same way on four hosts.
    
    • 
    
  • 
     
      No escape hatch; access hatches.
     
     Nothing steps outside the plan. Where an app
needs a platform widget, it uses a
     
      native module
     
     : a hyphenated tag like
     
      exact-map
     
     , backed by Swift, Kotlin or Rust, laid out by the kernel like any other box.
Where it needs the platform object Exact itself built (a
     
      UIView
     
     , a navigation
controller, a DOM element), it marks the node
     
      hatch="word"
     
     and its native code is
handed that object: an
     
      access hatch
     
     , the panel a machine is built with so its
insides can be reached. It configures what Exact made and changes Contract state
only by acting on authored nodes, as a person would.
    
    • 
   

   

    These limits serve the principles. An agent can't wire up a data race it can't write.
A plan with no JavaScript in it starts fast. A view written in CSS's own words lays out
the same on every host and looks at home on each.
   

   

    

     The compiler talks back
    

    
    
   

   

    
$ cargo run -q -p contract -- build app.contract
app.contract:4:5 [type-assign] `count` is `number`, cannot assign `string`
app.contract:7:23 [lower-unknown-attr] `text` has no attribute `size`; `size` is spelled `font-size` here, the web's name

   

   

    One run reports up to twenty independent errors, not just the first. Other subcommands:
    
     --json
    
    for tools,
    
     symbols
    
    (definitions and references as JSON),
    
     fmt
    
    (source-preserving),
    
     types
    
    (generates
    
     app.contract.d.ts
    
    for TypeScript sources),
and
    
     rust
    
    (shapes for a Rust data crate). The full language is specified in
    
     
      docs/contract-grammar.md
     
    
    .
   

   

    

     Example apps
    

    
    
   

   

    Each app lives in
    
     
      apps/<name>/
     
    
    . Run one on the web with
    
     bun host/web/dev.mjs --app <name>
    
    , on macOS with
    
     bun host/apple/build.mjs <name>-apple --run
    
    , and on iOS by adding
    
     --ios
    
    . All of
these screenshots come from the web host, taken by
    
     scripts/agent.mjs
    
    .
   

   

    To learn from, start with
    
     Shelf
    
    , the recipe app. It names no colour and no
font size, and
    
     scripts/no-tells.mjs
    
    holds it to that, so it shows what an app that
leaves presentation to the platform looks like on each host. Then read these four for
what each teaches. They were written before Exact left presentation to the platform
and paint their own colours and sizes, so take their structure, not their style:
   

   
    

     
      

       
        App
       
       
        What it teaches
       
      

     
     
      

       
        
         Caltrain
        
       
       
        A Rust data crate, authored tests, routes, an optional GPU module
       
      

      

       
        
         Weatherlight
        
       
       
        TypeScript with
        
         fetch
        
        and grants
       
      

      

       
        
         Fieldnotes
        
       
       
        Storage: SQLite, files, backup and restore
       
      

      

       
        
         Recorder
        
       
       
        The microphone through
        
         @exact/media-capture
        
        and
        
         @exact/recording
        
       
      

     
    

   
   
    

     
      

       
        
         Caltrain
        
       
       
        
         Weatherlight
        
       
       
        
         Spark
        
       
       
        
         Expose
        
       
      

      

       
        
         
          Caltrain
         
        
        

        The app that defines v1: nearby stations, live departure boards, search, theming, a Canvas 2D line map, and an aurora GPU sky. Rust data. Every host.
       		
       
        
         
          Weatherlight
         
        
        

        Weather from Open-Meteo under a GPU-animated sky that follows the hour you pick. TypeScript data and a wgpu module.
       		
       
        
         
          Spark
         
        
        

        A swipe deck: throw a card with your finger, and it flies off with your release velocity. Pan gestures and springs on every host.
       		
       
        
         
          Expose
         
        
        

        A pretend phone OS (lock screen, home, Messages with an AI assistant, Reader) set in custom fonts. TypeScript. The assistant needs an OpenRouter key.
       		
      

      

       
        
         Calendar
        
       
       
        
         Sparkline
        
       
       
        
         Photo Editor
        
       
       
        
         Video Player
        
       
      

      

       
        
         
          Calendar
         
        
        

        Month pages, draggable sheets, events dragged between days, wallpaper themes, SQLite. It lives outside
        
         apps/
        
        , so set
        
         EXACT_APP_DIR
        
        to run it.
       		
       
        
         
          Sparkline
         
        
        

        A market list of animated SVG charts that draw in and pulse.
       		
       
        
         
          Photo Editor
         
        
        

        Rotate, pan, and crop, through a native module.
       		
       
        
         
          Video Player
         
        
        

        A bundled clip that shrinks out of the way when the keyboard opens.
       		
      

     
    

   
   
    

     
      

       
        
         Exact Live
        
       
       
        
         Still, the interaction gallery
        
       
      

      

       
        
         
          Exact Live
         
        
        

        A creative-production workspace: a photo grid you reorder by dragging, a crew chat that can take a 10,000-message burst, and a Markdown runbook. Rust data.
       		
       
        
         
          Still
         
         (Interaction Gallery)
        
        

        Drag to reorder, pan and zoom photos, a resizable sheet with a nested list, and 100 to 25,000 records.
       		
      

      

       
        
         Reflow
        
       
       
        
         Textflow
        
       
      

      

       
        
         
          Reflow
         
        
        

        Seven typography studies after Cheng Lou's Pretext demos: text flowing around moving balls, a dragon, masonry, and a magazine spread. Line heights come from font metrics read at build time.
       		
       
        
         
          Textflow
         
        
        

        Text around shapes with CSS's
        
         shape-outside
        
        and
        
         wrap-flow
        
        : draggable orbs, a dancer, an editorial layout. One Rust walker shared by every host.
       		
      

      

       
        
         Markdown reader
        
       
       
        
         Conduit, the RealWorld app
        
       
      

      

       
        
         
          Markdown
         
        
        

        A Markdown reader that opens files from Finder or the command line (
        
         mdview README.md
        
        ). Its sibling
        
         
          LLP
         
        
        (
        
         llpview
        
        ) reads a folder of numbered design documents.
       		
       
        
         
          Conduit
         
         (RealWorld)
        
        

        The RealWorld Medium clone against its hosted API. It's the benchmark that compared Exact's web build with React 19. Web only.
       		
      

     
    

   
   
   
   

    

     More apps, labs, and stress tests
    

    
    
   

   
    

     
      

       
        App
       
       
        What it shows
       
       
        Notes
       
      

     
     
      

       
        
         Fieldnotes
        
       
       
        A local notebook with pins, search, SQLite storage, and JSON backup and restore
       
       
        TypeScript + Rust
       
      

      

       
        
         Messages
        
       
       
        A port of Expo's chat demo, talking to models through OpenRouter
       
       
        Needs
        
         bun apps/messages/service.ts
        
        and an OpenRouter key
       
      

      

       
        
         Type Tour
        
       
       
        Phone-OS screens as a type specimen for the Expose fonts
       
       
        No JavaScript at all
       
      

      

       
        
         Map Demo
        
       
       
        Native modules: MapKit on Apple and OpenStreetMap on the web
       
       
       
      

      

       
        
         Carousel
        
       
       
        A horizontal virtualized list of 25,000 cards
       
       
       
      

      

       
        
         Motion Gallery
        
       
       
        Animated GIF and WebP images and CSS keyframes, compared across hosts
       
       
       
      

      

       
        
         Update Lab
        
       
       
        Live replacement of Contract, TypeScript, and Rust in a running app
       
       
        Hand-testing lab
       
      

      

       
        
         Messages Stress
        
        ,
        
         Completion Storm
        
        ,
        
         Markdown Stress
        
       
       
        100k-message histories, 128 parallel requests, and 4 MiB documents, under load
       
       
        Opt-in workloads
       
      

      

       
        
         Native Fixture
        
        ,
        
         Auth Fixture
        
       
       
        The native-module interface; OAuth with PAR, DPoP, and PKCE against a local server
       
       
        Test fixtures
       
      

      

       
        
         Beacons, Tennis, …
        
       
       
        Games on the optional
        
         engine add-on
        
        : Rust gameplay, Contract menus
       
       
        
         bun game/dev.mjs beacons
        
       
      

     
    

   
   

    

     What works today, and what doesn't yet
    

    
    
   

   

    The v1 bar:
    
     one real application, not a demo, runs from a
single Contract source on web, macOS, iOS, and Linux, within the time budgets in
     
      rules/RULES.md
     
     .
    
    Caltrain is that application, and it runs on all four. Everything
else here was admitted because a real app needed it.
   

   

    

     Working
    

    
    
   

   
    
    
  • 
     
      Four hosts.
     
     Web, macOS (AppKit, no SwiftUI), iOS (UIKit, on the Simulator and
on devices), and Linux (GPU or CPU painting, DRM/KMS or headless). Existing Swift apps
can embed Exact sessions through ExactKit.
    
    • 
    
  • 
     
      Layout and text.
     
     CSS block, flex, and grid;
     
      position: static
     
     and containing
blocks;
     
      aspect-ratio
     
     ; declared fonts; text around shapes.
    
    • 
    
  • 
     
      Paint.
     
     Gradients, shadows,
     
      backdrop-filter
     
     , glass materials, complete SVG,
Canvas 2D on every host, and a wgpu GPU canvas loaded after first pixel.
    
    • 
    
  • 
     
      Motion.
     
     CSS transitions, springs,
     
      @keyframes
     
     , follow-and-release gestures (pan,
swipe, pinch) with release velocity, layout transitions, exit animations, and
scroll- or drag-linked timelines.
    
    • 
    
  • 
     
      Lists.
     
     Virtualized lists, vertical or horizontal, one level deep. The rows of a
vertical
     
      list
     
     are its platform's: UIKit's separators and highlight, a table on the Mac, one
line between rows on the web, with nothing drawn by the app.
    
    • 
    
  • 
     
      Controls and media.
     
     Inputs,
     
      select
     
     , a WYSIWYG Markdown editor on the web, macOS,
and iOS, images including animated ones, video, pickers for an app's declared file
types, and share.
    
    • 
    
  • 
     
      Data.
     
     TypeScript or Rust sources, optionally on a worker. Grant-checked
     
      fetch
     
     and
streams, files and SQLite (native and in the browser), Keychain secrets, and OAuth
sign-in. A router keeps a stack per tab.
    
    • 
    
  • 
     
      Native modules.
     
     Platform widgets as hyphenated tags.
    
    • 
    
  • 
     
      The web, server side.
     
     Pages pre-rendered at build time or per request by a Rust
renderer, then adopted in place instead of hydrated.
    
    • 
    
  • 
     
      Delivery.
     
     
      scripts/deploy.mjs
     
     publishes the web root and signed update bundles,
which installed apps fetch after first pixel. Apple apps check every fifteen
minutes while active under every activation policy;
     
      deploy.check.interval
     
     overrides the interval in seconds. Checks stage a candidate;
     
      deploy.activate
     
     controls when it applies. TypeScript and Rust logic can be
replaced live in development. Every web build gets an install page, and
     
      exact release
     
     signs and notarizes a Mac app.
    
    • 
    
  • 
     
      Agents and tests.
     
     The ten operations on every host, including a physical
iPhone; Contract tests; source maps; filmed screenshots.
    
    • 
   

   

    

     Not yet, or not at all
    

    
    
   

   
    
    
  • 
     
      Windows.
     
     Apps default to ink on a DirectX 11 composition swap chain,
or CPU when the manifest declares
     
      game
     
     .
     
      host.windows.painter: "ink"
     
     or
     
      "cpu"
     
     selects either painter, and
     
      EXACT_PAINTER
     
     overrides both.
Skirmish is a standalone game built with Exact's optional game engine;
the CPU default preserves its module-owned window presentation.
     
      Windows Desk
     
     demonstrates
native controls over Contract and the kernel with an app-local Win32 presenter;
general Windows control parity and delivery remain unfinished.
    
    • 
    
  • 
     
      Android.
     
     Early. An app builds for Android and runs on an emulator or a phone:
     
      bun exact.mjs android
     
     builds it,
     
      bun exact.mjs test android
     
     runs its tests, and
     
      bun exact.mjs agent android …
     
     drives it. It needs the Android SDK, the Rust target
     
      aarch64-linux-android
     
     , and the Hermes Android bundle
(
     
      bun scripts/hermes-android.mjs build
     
     ) until an Ibex release ships one. Delivery and
store packaging don't exist yet.
    
    • 
    
  • 
     
      No JSX or React tier.
     
     Nothing runs JavaScript above the data seam. The door stays
open, but no one is building it.
    
    • 
    
  • 
     
      TypeScript can't import npm packages' code yet.
     
     
      app.ts
     
     imports its own local
files; from a package it imports only types (
     
      import type
     
     ), which the build checks
and never runs.
    
    • 
    
  • 
     
      Code updates in production.
     
     Signed delivery covers plans and assets. Signed
delivery of TypeScript or Rust modules isn't implemented, and app-store rules limit
it anyway.
    
    • 
    
  • 
     
      Linux editing.
     
     The web and Apple hosts edit; Linux reads. Linux also has no
word segmenter, so flowed Thai, Lao, Khmer, and Myanmar text breaks only at spaces.
    
    • 
    
  • 
     
      Out on purpose for v1.
     
     Camera access, a gesture arena, general layout animation,
grid or masonry virtualization, a general webview beyond
     
      iframe
     
     , and a devtools UI.
    
    • 
    
  • 
     
      No packaged CLI.
     
     You work from a source checkout.
     
      exact new
     
     apps refer to it by
path.
    
    • 
   

   

    

     Repository map
    

    
    
   

   
    

     
      

       
        Path
       
       
        What's there
       
      

     
     
      

       
        
         
          kernel/
         
        
       
       
        
         exact-kernel
        
        : the node arena, wire frames, transactions, Taffy layout, and the export.
        
         
          kernel/tables/schema.json
         
        
        declares every node type, property, and opcode.
       
      

      

       
        
         
          contract/
         
        
       
       
        The Contract compiler (
        
         syntax
        
        →
        
         types
        
        →
        
         analyze
        
        →
        
         lower
        
        ), its CLI, and the corpus
       
      

      

       
        
         
          plan/
         
        
        ,
        
         
          runner/
         
        
       
       
        The plan format, generated from one JSON authority, and the VM that runs it
       
      

      

       
        
         
          motion/
         
        
       
       
        CSS transitions, springs, and the seekable clock for non-web hosts
       
      

      

       
        
         
          host/
         
        
       
       
        
         web/
        
        ,
        
         web-js/
        
        (the JS target),
        
         apple/
        
        (Rust core, ExactKit Swift package, AppKit and UIKit),
        
         linux/
        
        ,
        
         render/
        
        (server pages), plus update adapters and rasterizers
       
      

      

       
        
         
          js/
         
        
        ,
        
         
          logic/
         
        
        ,
        
         
          data/
         
        
       
       
        The TypeScript executor (Hermes, and the browser's engine on the web), Rust logic modules, and the data seam
       
      

      

       
        
         
          gpu/
         
        
        ,
        
         
          canvas/
         
        
        ,
        
         
          textflow/
         
        
        ,
        
         
          markdown/
         
        
       
       
        Capabilities loaded on demand: the wgpu canvas, Canvas 2D, text around shapes, and the Markdown editor
       
      

      

       
        
         
          route/
         
        
        ,
        
         
          update/
         
        
        ,
        
         
          bake/
         
        
        ,
        
         
          filesystem/
         
        
       
       
        The router, the signed update store, delivery baking, and app-owned files
       
      

      

       
        
         
          apps/
         
        
        ,
        
         
          examples/
         
        
        ,
        
         
          game/
         
        
       
       
        The apps above, the Calendar example, and the optional game engine
       
      

      

       
        
         
          scripts/
         
        
       
       
        
         exact.mjs
        
        ,
        
         agent.mjs
        
        ,
        
         smoke.mjs
        
        ,
        
         metrics.mjs
        
        ,
        
         deploy.mjs
        
        , and the checks
       
      

      

       
        
         
          docs/
         
        
       
       
        Guides for app authors: start here, the Contract grammar, recipes, and pitfalls
       
      

      

       
        
         
          rules/
         
        
       
       
        
         
          RULES.md
         
        
        , how work on Exact happens
       
      

      

       
        
         
          vendor/taffy/
         
        
       
       
        Taffy, plus Exact's patches
       
      

     
    

   
   

    

     Working on Exact
    

    
    
   

   

    Start with
    
     
      rules/RULES.md
     
    
    , one page on how work happens here. Agents
should also read
    
     
      AGENTS.md
     
    
    . In short:
   

   
    
    
  • 
     
    
      
       Six blocking checks, 65 seconds in total.
      
      Anything slower runs asynchronously,
per commit.
     
    
     
    
      
    cargo build --all-targets --keep-going
cargo test --tests --no-fail-fast
cargo clippy --all-targets --keep-going -- -D warnings && cargo fmt --all -- --check
bun scripts/caps.mjs     # budgets: 1,500 lines per source file, document caps
bun scripts/boot.mjs     # counts the module graph before first pixel
cargo check --workspace --all-targets --keep-going   # every crate compiles
    
     
    
     
    
      The first three build and test Cargo's
      
       default-members
      
      . The last compiles every
other crate too, so a host or an app outside them cannot stop compiling unseen. It
needs the pinned Bun (
      
       package.json
      
      ) first on
      
       PATH
      
      : app crates' build scripts run it.
     
    
    
    • 
    
  • 
     
    
      
       Verify by running, not by reading.
      
      Build the app a change touches and drive it:
      
       bun scripts/smoke.mjs <web|macos|ios|linux>
      
      drives the whole app on that host.
     
    
    
    • 
    
  • 
     
    
      
       Delete; don't deprecate.
      
      Before 1.0 there are no compatibility shims. Generated
files are built, never committed.
     
    
    
    • 
    
  • 
     
    
      
       Agents remove apparatus freely and add none
      
      (checks, scripts, registries, design
documents) without a person saying so.
     
    
    
    • 
    
  • 
     
    
      
       A spec gets written only when it has an implementer and a date.
      
     
    
    
    • 
   

   

    Detailed operational notes cover toolchains, the Contract CLI's JSON formats, source
maps, TypeScript and Rust data modules, storage, live replacement, delivery trust, the
install page, and the stress harnesses. They're in
    
     
      docs/reference.md
     
    
    .
   

   

    The workspace is MIT-licensed (
    
     Cargo.toml
    
    ).
   

   

    Exact’s Snapback4 adapter uses published
    
     0.4.33
    
    with the matching immutable
Rust source revision
    
     3653cae823145170df3e720f5e321bd1b5b4d79d
    
    .
See
    
     the snapback4 package's README
    
    for wiring and device rebuilds.
   

  

 




        

      

    
    

        

          
Process Explorer for macOS

        

        

          Hacker News
        

	

	  github.com
	

        

          2026-11-09 17:30:41
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   

    

     Sysinternals Process Explorer for Mac
    

    
    
   

   

    Sysinternals Process Explorer for Mac is a native macOS implementation of the core Process Explorer experience. It provides a live process tree, lower-pane module/handle/thread inspection, rich per-process properties, system-wide performance graphs, code-signing inspection, and macOS-specific equivalents for Process Explorer workflows.
   

   

    The app is built with Swift, SwiftUI, and AppKit, with sampling backed by public macOS APIs such as
    
     libproc
    
    ,
    
     sysctl
    
    , Mach host statistics, Security.framework, IOKit, Metal, and optional privileged helper support.
   

   

    
     Sysinternals Process Explorer for Mac showing process details and system information
    
   

   

    

     Features
    

    
    
   

   
    
    
  • 
     Live process tree with Process Explorer-style colors for services, own processes, new/deleted processes, suspended processes, sandboxed processes, and packed images.
    
    • 
    
  • 
     Frozen process-name pane with horizontally scrollable metric columns.
    
    • 
    
  • 
     Persisted process-list column widths, ordering, column sets, and selected columns.
    
    • 
    
  • 
     Type-to-select in process and lower-pane lists.
    
    • 
    
  • 
     Immediate tooltips for truncated cells and process path/command-line detail.
    
    • 
    
  • 
     Pause/resume refresh with the spacebar.
    
    • 
    
  • 
     Native menu bar with File, Options, View, Process, Find, Window, and Help commands.
    
    • 
    
  • 
     Toolbar actions for refresh, save, process properties, kill, lower pane, find handle/DLL, target-window picker, and System Information graphs.
    
    • 
    
  • 
     Lower pane modes for DLLs/images, handles/file descriptors, and threads.
    
    • 
    
  • 
     Lower-pane row highlighting for newly appeared and deleted items.
    
    • 
    
  • 
     Per-process Properties window with Image, Performance, Performance Graph, Threads, TCP/IP, Security, Environment, and Strings tabs.
    
    • 
    
  • 
     TCP/IP tab with local address, remote address, async reverse-DNS remote name lookup, TCP state, and column persistence.
    
    • 
    
  • 
     Security/signature detail with signer, publisher, certificate chain, Team ID, notarization status, platform/ad-hoc status, validation reason, SHA-256, and VirusTotal integration.
    
    • 
    
  • 
     Module/image detail windows with metadata, signature verification, VirusTotal, Reveal in Finder, and Search Online.
    
    • 
    
  • 
     Handle/file-descriptor detail windows.
    
    • 
    
  • 
     System Information window with Summary, CPU, Memory, I/O, Network, and GPU pages.
    
    • 
    
  • 
     System Information graphs for CPU, memory, swap, disk I/O, network I/O, GPU, and per-core CPU usage.
    
    • 
    
  • 
     Performance vs. efficiency core labeling and coloring on Apple Silicon.
    
    • 
    
  • 
     Hardware details for CPU topology/cache, memory/page information, storage, network interfaces, GPU device capabilities, and OS/machine data.
    
    • 
    
  • 
     Menu-bar CPU history item.
    
    • 
    
  • 
     Process actions: kill, kill tree, suspend/resume, set priority/nice, restart, bring to front, sample process, Search Online, Check VirusTotal.
    
    • 
    
  • 
     Optional privileged helper architecture for cross-user and privileged operations.
    
    • 
    
  • 
     Release scripts for DMG creation, signing, and notarization.
    
    • 
   

   

    

     Requirements
    

    
    
   

   
    
    
  • 
     macOS 14 or later for the GUI app target.
    
    • 
    
  • 
     Xcode 26.6 or later recommended for the current project configuration.
    
    • 
    
  • 
     Swift 5.9 toolchain or later.
    
    • 
    
  • 
     
      xcodegen
     
     for regenerating
     
      ProcexpMac.xcodeproj
     
     from
     
      project.yml
     
     .
    
    • 
   

   

    Install
    
     xcodegen
    
    if needed:
   

   

    

     Build
    

    
    
   

   

    Generate the Xcode project and build the Debug app:
   

   

    
xcodegen generate
xcodebuild -scheme ProcexpMac -configuration Debug build

   

   

    The Debug app is written under Xcode DerivedData. On this machine the path is typically:
   

   

    
~/Library/Developer/Xcode/DerivedData/ProcexpMac-czqddcuyalgzfgebjezrhssregtw/Build/Products/Debug/ProcExp\ \(Dev\).app

   

   

    You can also open the generated project in Xcode:
   

   

    
xcodegen generate
open ProcexpMac.xcodeproj

   

   

    

     Run
    

    
    
   

   

    After a Debug build, launch the app with:
   

   

    
open "$HOME/Library/Developer/Xcode/DerivedData/ProcexpMac-czqddcuyalgzfgebjezrhssregtw/Build/Products/Debug/ProcExp (Dev).app"

   

   

    If your DerivedData suffix differs, locate the product with:
   

   

    
find ~/Library/Developer/Xcode/DerivedData -path '*/Build/Products/Debug/ProcExp (Dev).app' -print

   

   

    To relaunch a freshly built app from this workspace:
   

   

    
app="$HOME/Library/Developer/Xcode/DerivedData/ProcexpMac-czqddcuyalgzfgebjezrhssregtw/Build/Products/Debug/ProcExp (Dev).app"
pids=$(pgrep -f "$app/Contents/MacOS/ProcexpMac" || true)
if [[ -n "$pids" ]]; then kill $pids 2>/dev/null || true; fi
open -n "$app"

   

   

    

     Bundle identity: development vs. official
    

    
    
   

   

    Unqualified Xcode and local ad-hoc builds use
    
     ProcExp (Dev).app
    
    with bundle
ID
    
     com.sysinternals.procexpmac.dev
    
    . Its helper uses the separate launchd and
Mach service ID
    
     com.sysinternals.procexpmac.dev.helper
    
    . The development app,
helper approval, preferences, and LaunchServices registration therefore do not
replace an installed official copy.
   

   

    The official identities are reserved for an explicit Developer ID build or the
Azure release pipeline:
    
     ProcExp.app
    
    ,
    
     com.sysinternals.procexpmac
    
    , and
    
     com.sysinternals.procexpmac.helper
    
    . The build and signing scripts validate the
entire tuple before signing or publishing it.
   

   

    

     Validate
    

    
    
   

   

    Run the full Swift package test suite:
   

   

    Run the live smoke test:
   

   

    Run focused test suites:
   

   

    
swift test --filter ProcexpModelTests
swift test --filter ProcexpNetworkTests
swift test --filter ProcexpSigningTests

   

   

    

     TCP/IP Test Fixture
    

    
    
   

   

    The repository includes a small stateful TCP fixture for testing the TCP/IP tab:
   

   

    
swift build --product ProcexpTcpFixture
.build/debug/ProcexpTcpFixture --duration 3600 --remote-host github.com --remote-port 22

   

   

    The fixture opens a loopback listener, creates a loopback established connection, and optionally opens a DNS-resolved remote TCP connection. Select the fixture process in Process Explorer and open Properties > TCP/IP to inspect the sockets and remote-name resolution.
   

   

    

     Privileged Helper
    

    
    
   

   

    The app can use an optional privileged root helper for operations that require
elevated privileges, such as richer cross-user process detail (full process
list, threads, modules, environment) and privileged process control. The helper
is a launchd daemon reached over XPC; the app registers it with
    
     SMAppService
    
    .
   

   

    macOS gates
    
     SMAppService
    
    daemon registration on the app's code signature and
on an explicit user approval. The app must be signed with a
    
     stable, non-ad-hoc
    
    identity — a
    
     Developer ID Application
    
    certificate for distribution, or a
self-signed identity for local development — and you approve the daemon once in
    
     System Settings ▸ General ▸ Login Items & Extensions
    
    . The sections below
cover both the Developer ID install and a local self-signed test.
   

   

    

     Testing with a Developer ID certificate (real install)
    

    
    
   

   

    This is the same experience end users get.
   

   

    
DEV_SIGN_IDENTITY="Developer ID Application: NAME (TEAMID)" \
bash Scripts/dev_install_helper.sh

   

   

    This builds a Release app, embeds the helper and its launchd plist at
    
     Contents/Library/LaunchDaemons/
    
    , signs everything inside-out with the Hardened
Runtime and entitlements, installs
    
     /Applications/ProcExp.app
    
    , and launches
it. Then, in the app, choose
    
     ProcexpMac ▸ Install Privileged Helper…
    
    and
approve the daemon in
    
     System Settings ▸ General ▸ Login Items & Extensions
    
    .
After approval the app adopts the privileged provider and shows all processes.
   

   

    

     Testing without a Developer ID certificate (local self-signed)
    

    
    
   

   

    For local development you can exercise the same privileged code path with a
throwaway self-signed identity. On first run the script creates the identity in
a dedicated keychain (no login-keychain involvement), builds a signed,
helper-embedded app, installs it to
    
     /Applications
    
    , and launches it:
   

   

    
bash Scripts/dev_install_helper.sh

   

   

    Then, one time only, choose
    
     ProcexpMac ▸ Install Privileged Helper…
    
    and
approve the daemon in
    
     System Settings ▸ General ▸ Login Items & Extensions
    
    .
After that, every subsequent run of the script rebuilds and relaunches the
signed app with the helper already enabled, so the elevated path is available on
each iteration:
   

   

    
bash Scripts/dev_install_helper.sh          # Debug (default), fast
CONFIGURATION=Release bash Scripts/dev_install_helper.sh
RESTART_HELPER=1 bash Scripts/dev_install_helper.sh   # after changing helper code

   

   

    Notes:
   

   
    
    
  • 
     The script defaults to a
     
      Debug
     
     build signed with the
     
      "ProcexpMac Dev"
     
     self-signed identity. It installs
     
      /Applications/ProcExp (Dev).app
     
     with the
     
      .dev
     
     app and helper identifiers.
     
      SMAppService
     
     ties daemon registration to
the app's signature and location, so reinstalling the same-identity build
keeps the development helper registered.
    
    • 
    
  • 
     The app changes take effect on relaunch; the root
     
      helper
     
     keeps running its
already-loaded binary, so pass
     
      RESTART_HELPER=1
     
     (prompts for sudo) when you
change the helper's own code.
    
    • 
    
  • 
     A corporate-managed Mac can prompt for a keychain password when
     
      codesign
     
     touches your login keychain and reject your account password if the login
keychain drifted out of sync after a rotation. The dedicated keychain the
script creates avoids that entirely.
    
    • 
   

   

    

     Verifying and cleaning up
    

    
    
   

   

    Check whether the daemon is registered and running as root:
   

   

    
launchctl print system/com.sysinternals.procexpmac.dev.helper

   

   

    For an explicit Developer ID install, inspect the official service instead:
   

   

    
launchctl print system/com.sysinternals.procexpmac.helper

   

   

    If registration succeeded, the process list shows previously hidden cross-user
and system processes. If the daemon is registered but not yet enabled, approve
it in
    
     System Settings ▸ General ▸ Login Items & Extensions
    
    and it becomes
active. Repeated reinstalls can clear a previously remembered approval, in which
case macOS asks you to approve it again. If registration is refused outright
(for example, an ad-hoc signature), the app reports that the helper could not be
registered and continues in unprivileged mode.
   

   

    Remove the installed app and unregister the helper:
   

   

    
bash Scripts/dev_uninstall_helper.sh

   

   

    The cleanup script defaults to the development tuple. To remove an explicit
Developer ID test install instead, run:
   

   

    
PROCEXP_LOCAL_FLAVOR=official bash Scripts/dev_uninstall_helper.sh

   

   

    Remove the throwaway signing keychain when finished:
   

   

    
security delete-keychain "$HOME/Library/Keychains/procexp-dev.keychain-db"

   

   

    See
    
     Helper/README.md
    
    and
    
     docs/RELEASE.md
    
    for the helper architecture and the full Developer ID signing/notarization
pipeline.
   

   

    

     Release Build
    

    
    
   

   

    Build a release DMG:
   

   

    
bash Scripts/build_release.sh

   

   

    This local ad-hoc command creates
    
     build/ProcExp-Dev.dmg
    
    containing
    
     ProcExp (Dev).app
    
    . To prepare the canonical app for Developer ID signing:
   

   

    
PROCEXP_BUILD_FLAVOR=official PACKAGE_DMG=0 bash Scripts/build_release.sh

   

   

    Sign and notarize a release build after configuring Developer ID credentials:
   

   

    
bash Scripts/sign_notarize.sh

   

   

    See
    
     docs/RELEASE.md
    
    for the full release pipeline.
   

   

    

     Project Layout
    

    
    
   

   
   

    

     Notes
    

    
    
   

   

    macOS does not expose every Process Explorer data source through public APIs. Where macOS denies access or a metric is not available through supported APIs, the UI leaves values blank rather than fabricating data. Some details become available only for same-user processes or when the privileged helper is active.
   

  

 




        

      

    
    

        

          
Docker has always used microVMs (well, since 2016)

        

        

          Lobsters
        

	

	  dave.recoil.org
	

        

          2026-11-09 17:29:01
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   Docker has always used microVMs (well, since 2016)
  

  

   There's a lot of buzz about "microVMs", where a workload runs
        with a stripped down Linux kernel, on a minimalist VMM such as
   
    firecracker
   
   on top of a hypervisor
        like KVM or Xen. MicroVMs are often contrasted to, and considered more secure than,
        traditional Linux Docker containers.
        What if I told you that Docker Desktop has always used microVMs? (since 2016)
  

  

   Always has been meme: wait, Docker uses microVMs? Always has been (since 2016)
  

  

   Unikernels are microVMs
  

  

   Unikernels can be considered an early form of microVM. Rather than booting a full Linux kernel on a full
        VMM, a unikernel links an app with only the drivers, filesystems and subsystems it actually needs; other code is
        omitted. For example a
   
    MirageOS
   
   unikernel app would have no processes, probably no filesystem,
        only one vCPU. Certainly no ssh or shell (unless you really want those). The VMM that hosts the Mirage unikernel was also
        minimal (see
   
    Solo5
   
   and
   
    mirage-solo5
   
   ). No legacy required.
        We were so confident in the security of the system that we ran a
   
    bitcoin pinata
   
   offering 10BTC to any
        hacker able to claim it. The BTC went unclaimed.
  

  

   Boot can be really fast too:
        the "Just-In-Time Summoning of Unikernels" project
          (
   
    paper
   
   ,
   
    code
   
   )
        optimized x86 VM creation time down to about 20ms (120ms on an underpowered 2015 ARM dev board)
  

  

   The main (obvious) downside of unikernels is having to link your app with a bunch of kernel code.
        A lot of people would like to run existing Linux programs!
  

  

   While we were developing Unikernels, Docker was busy inventing the modern form of Linux containers and revolutionising
        how software is built, shared and run.
   
    Docker acquired Unikernel Systems in 2016
   
   and we combined the best of Unikernels (microVMs) and Linux containers into Docker for Mac (later Docker Desktop).
  

  

   A library VMM for Desktop applications
  

  

   Our priority back then wasn't to add microVMs to Docker for their own sake.
        Instead our goal was to make Docker feel like a native app on Mac and Windows, rather than a bundle of components.
        Using our
   
    Mirage Unikernel libraries
   
   we started building a "library VMM": a VMM which could
        be embedded inside the Docker application, and which would be single purpose, minimal, secure
        and fast. The first version was called
   
    hyperkit
   
   (a fork of
   
    xhyve
   
   ,
          itself derived from
   
    bhyve
   
   ).
        We linked the C code directly with the
   
    MirageOS block layer
   
   and used the
   
    Mirage userspace TCP/IP stack
   
   in
          a gvisor-like network stack
   
    vpnkit
   
   .
          The VMM code continues to evolve and is now called
   
    Docker VMM
   
   .
   
    
     1
    
   
  

  

   The VM kernel and root filesystem were minimal too, based on the
   
    LinuxKit
   
   project. The current version is an
        even more slimmed down and efficient variant but conceptually the same, similar to
   
    containerd/nerdbox
   
   .
  

  

   Docker for Mac in 2015-2016
  

  

   Docker for Mac began in 2015 as
   
    Project Piñata
   
   , a skunkworks project
        to make Docker useful to more developers. In this 2018 tweet, Solomon Hykes recalls
        Docker's first use of unikernel technology and the collaboration between Paris,
        Cambridge and San Francisco:
  

  

   

    “It was our first use of Unikernel tech, and our first Paris/Cambridge/SF collaboration.”
   

   — Solomon Hykes (@solomonstre)
   
    February 7, 2018
   
  

  

   For Docker for Mac (later renamed Docker Desktop) this allowed:
  

  
    
   
  • 
    
     Running rootless on all platforms.
    
    Without requiring "rootless inside Linux":
          the whole Linux kernel is untrusted, so even a
    
     Linux CVE
    
    doesn't matter.
   
    • 
   
  • 
    
     Minimal devices.
    
    We could carefully limit the host / VM interface, making it easy to understand and audit.
   
    • 
   
  • 
    
     VPNs and network policy.
    
    It was easy to interoperate with VPNs, and to extend later to impose
          networking policy such as
    
     Registry Access Management
    
    .
   
    • 
  

  

   Here's the OG 2015 Docker for Mac beta installation experience:
  

  

   And now in 2026
  

  

   The Docker microVM tech is the foundation of both Docker Desktop and also
   
    Docker Sandboxes
   
   (
   
    why microVMs
   
   ),
          where each sandbox runs in a separate microVM, completely isolated from each other and the host.
        Docker Sandboxes enables you to do things like
   
    run your favourite coding agent and harness securely
   
   ,
        with strict isolation and governance.
  

  

   
    CACM 2026 - A Decade of Docker Containers
   
  

  

   To see what Docker microVM's can do, install
   
    Docker Sandboxes (sbx)
   
   and try `sbx run claude`.
  

  

   Further reading
  

  

   To read more about the history of the tech, check out the article
   
    A Decade of Docker Containers
   
   (Communications of the ACM).
  

  

   Join the discussion on
   
    LinkedIn
   
   .
  

  

   Footnote
  

  

   
    1
   
   Although we were aiming to make everything a library and link into a static
      unikernel-like process, for technical reasons it makes sense to still have a single
      host process per VM.
   
    ↩
   
  

  

   ChangeLog
  

  
    
   
  • 
    2026-10-03: original version
   
    • 
   
  • 
    2026-10-04: added more history and cool install video
   
    • 
   
  • 
    2026-10-05: added an inline timeline, with earlier systems context, the Bitcoin Piñata security challenge, Solo5 + ukvm integration and Docker for Mac release milestones
   
    • 
   
  • 
    2026-10-09: added Simon Crosby's 2012 description of Bromium's micro-VMs, Intel Clear Containers and Kata Containers to the timeline
   
    • 
   
  • 
    2026-10-09: added Project Piñata's 2015 origins and Solomon Hykes's tweet about the first use of unikernel technology at Docker
   
    • 
  

 




        

      

    
    

        

          
Reverse engineering a vintage diode-transistor logic chip

        

        

          Lobsters
        

	

	  www.righto.com
	

        

          2026-11-09 17:25:03
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   Going through a collection of old parts, CuriousMarc encountered some ICs that he couldn't
identify.
He opened up one of these ICs, and I studied it under the microscope.
After some reverse engineering, I determined that it was a logic chip that implemented four NAND gates
using old-fashioned diode-transistor logic (DTL).
   
    
     1
    
   
   The chip turned out to be the ST680A, a member of the Signetics 600 series of chips from 1965.
In this article, I discuss the circuitry in this chip and how diode-transistor logic works.
  

  

   
    The die of the ST680A under the microscope.
   
  

  

   The die of the ST680A under the microscope.
  

  

   Integrated circuits can be packaged in many ways. One of the most popular is the
plastic DIP (Dual In-line Package), a black rectangle of epoxy with two rows of metal
pins.
This type of package was
   
    invented
   
   by Signetics: "Introduced in late 1965, the 600 series was the first integrated circuit family to be offered in a solid, plastic, dual in-line package (DIP)."
Earlier integrated circuits were packaged in round metal cans or in small flat-packs.
In 1965, engineers at Fairchild invented the DIP, which had two
rows of pins on 0.1" spacing.
Unlike the surface-mounted flat-pack, the DIP had pins that were inserted into holes, making
manual or automated assembly quick and easy.
Because the pins of a DIP were on a regular grid, rather than the circular pattern of a metal
can, circuit board design and manufacturing were also easier
(
   
    details
   
   ).
The first DIP chips had ceramic packages.
The plastic DIP, introduced by Signetics, was much cheaper and became very popular.
  

  

   
    An advertisement for the Signetics 600 series. From Electronics, March 21, 1966.
   
  

  

   An advertisement for the Signetics 600 series. From
   
    
     Electronics
    
   
   , March 21, 1966.
  

  

   The plastic DIP is less popular with me, however, because it is harder to open.
With a ceramic package, I can simply tap it with a chisel and pop it open, but
that doesn't work with epoxy packages.
An epoxy package can be dissolved with nitric or sulfuric acid, but I try to avoid dangerous acids.
Instead, CuriousMarc used
   
    Antoine's hot air
   
   decapping method.
Unfortunately, the hot air technique doesn't always work. In this case, tiny bits of epoxy
were stuck to the die, obscuring the circuitry.
I used a few drops of boiling sulfuric acid to clean the die.
(I'm okay with sulfuric
acid in tiny quantities.)
  

  

   
    The die on its metal frame.
   
  

  

   The die on its metal frame.
  

  

   The photo above shows the silicon die
on its metal frame, the lead frame.
The golden blobs are where
the bond wires were attached to the die.
You can see the doped silicon regions that form diodes and bipolar NPN transistors,
as well as 16 resistors in the center, forming serpentine paths.
  

  

   Most chips have a passivation layer—a thin layer of silicon dioxide—over the chip.
Inconveniently, this old chip didn't have a passivation layer, so the acid also stripped off
the metal layer. (A few remnants are visible in the upper left.)
Without the metal layer, I had to guess at how the components were connected to
form logic gates.
The die has very faint color differences where the silicon was protected by the metal,
so that helped.
Eventually, I came up with the diagram below, showing how the metal
layer was probably configured.
This wiring reveals that the chip implements four DTL NAND gates, which I'll describe
in more detail below.
One puzzle was that the chip has two unused diodes, indicated with question marks below.
  

  

   
    The metal layer for a quad NAND chip. I desaturated the image to make the labels clearer.
   
  

  

   The metal layer for a quad NAND chip. I desaturated the image to make the labels clearer.
  

  

   Transistors, diodes, and resistors
  

  

   In this section, I'll explain how the patterns in the image correspond to components
of the circuit.
The silicon die is doped with various impurities to form regions with different
electrical characteristics.
These regions appear red or green under the microscope due to thin-film effects.
As a result, 
the chip's transistors, diodes, and resistors are visible.
  

  

   The chip is made from bipolar NPN transistors, which have a completely different
construction from the MOS transistors in modern ICs.
In an NPN transistor, the current from the collector to the emitter is controlled
by the current through the base.
The collector is a large region of N-type silicon, silicon that is doped with
atoms such as phosphorus or arsenic. 
Since these elements have one more valence electron than silicon, they give the
silicon more negative charge carriers, so it is called N for negative.
The N-type silicon happens to appear reddish.
  

  

   On top of the collector, the base is a thin region of P-type silicon, which appears green.
This silicon has been doped with atoms such as boron or gallium, which have 
one fewer valence electron than silicon. The missing electrons form "holes", which
act as positive charge carriers.
Finally, the emitter is N-type silicon, on top of the base layer.
These layers work together through semiconductor magic, amplifying the base current.
  

  

   
    Two NPN transistors on the chip. The second transistor is a larger output transistor.
   
  

  

   Two NPN transistors on the chip. The second transistor is a larger output transistor.
  

  

   The chip's output transistors are slightly larger so they can sink more current.
In the transistor on the right above, note that the collector contact wraps around three sides of
the transistor. 
The emitter is also larger, with an L-shaped contact.
According to the datasheet, each output transistor can sink 2.5 mA of current.
  

  

   The chip uses many diodes since it is diode-transistor logic. 
The structure of a diode is similar to a transistor, but without the emitter.
In a diode, current flows from the cathode (P-type silicon) to the anode (N-type).
  

  

   
    A diode and a resistor on the chip.
   
  

  

   A diode and a resistor on the chip.
  

  

   The chip uses 16 resistors, located in the middle of the die.
A resistor is constructed from a long, thin region of doped silicon.
Since silicon has moderately high resistance, a long strip of silicon acts
as a resistor.
Most of the resistors have a serpentine layout to fit a long resistor into a smaller area.
These resistors consist of P-type silicon (green) in a "tub" of N-type silicon (red).
The tub is connected to the positive voltage supply; since current doesn't flow from
N-type silicon to P-type silicon, this isolates the resistors from each other.
  

  

   Operation of a DTL gate
  

  

   Logic gates can be created in many ways.
The earliest integrated circuits (such as the ones in the Apollo Guidance Computer)
used Resistor-Transistor Logic (RTL), where logic gates were constructed from resistors
and transistors.
  

  

   In March 1962, Signetics announced the first family of commercial Diode-Transistor Logic
(DTL) integrated circuits (
   
    details
   
   ).
By using diodes on the inputs instead of resistors, DTL provided better performance than
RTL. 
However, DTL soon became overshadowed by TTL (Transistor-Transistor Logic), which
was faster and used less power. (If you built digital circuits a few decades ago, you're
probably familiar with the popular 7400 series of TTL chips.)
  

  

   The diagram below shows how the DTL NAND gate works.
If both inputs are high, the current from the first resistor flows through the
base of the first transistor, turning it on.
The transistor amplifies this current, passing a much larger current from the
transistor's collector to the transistor's emitter.
This current goes through the base of the second transistor, which turns on the
second transistor.
The second transistor passes an even larger current from the output pin to ground,
pulling the output pin low.
  

  

   
    The DTL NAND gate with both inputs high. The schematic is from the datasheet.
This circuit is considerably more complicated than the DTL gate on Wikipedia.
   
  

  

   The DTL NAND gate with both inputs high. The schematic is from the datasheet.
This circuit is considerably more complicated than the DTL gate on
   
    Wikipedia
   
   .
  

  

   But if one of the input pins is pulled low, the current from the resistor goes through
the diode instead of the transistor.
The first transistor turns off, and without a base current, the second transistor turns off.
The third resistor pulls the output high.
Thus, the output is low only if both inputs are high: a NAND gate.
  

  

   
    The DTL NAND gate with an input low.
   
  

  

   The DTL NAND gate with an input low.
  

  

   I'll point out a few features of this circuit.
The diodes on the inputs ensure that one input doesn't affect the other input.
The diode in the middle raises the voltage on the first transistor's emitter, so it
requires more voltage to turn on, reducing the sensitivity to noise.
The output uses a resistor to pull the output high; more advanced circuits use another
transistor.
When the output is low, the third resistor is still "trying" to pull the output high,
which is wasting power.
Moreover, the resistor limits the output current, so the high output is fairly weak.
In some DTL families, you can get gates with different values for the output resistor,
so you can select the tradeoff between wasting power and having an output that is too weak.
  

  

   If you've used TTL integrated circuits from the 1970s, you know that chips usually have power
and ground on diagonal pins: ground on pin 7 and power on pin 14.
(Putting power and ground diagonally opposite both helps die layout and circuit board layout.)
Much to my surprise, I found that the Signetics chips predate this standard and have
ground on pin 1 and power on pin 8: still diagonal, but the wrong diagonal!
The diagram below shows how the four NAND gates are wired in the chip.
  

  

   
    Pinout of the 680A quad NAND gate. From the databook.
   
  

  

   Pinout of the 680A quad NAND gate. From the
   
    databook
   
   .
  

  

   Three chips from one die
  

  

   When I examined the die under the microscope, I figured out the circuit, but I was puzzled
by two extra diodes, as if two NAND gates had a third input that wasn't used.
The explanation is that Signetics used the same silicon layout for at least three different
chips, applying a different metal layer for different functionality.
This saved money since it's much cheaper to produce a single optical mask for the metal layer
than a complete set of new masks.
Signetics sold semi-custom ICs to customers, using an approach called variFEBS (Variable
Functional Electronics Blocks). This approach used a custom metal layer on top of
fixed silicon, providing custom circuits without the cost of a full mask set.
These circuits didn't sell well, but Signetics used the same approach for standard ICs.
  

  

   
    Pinout of the 670A triple NAND gate and the 616A quad NAND gate. All three chips have some similarities, such as using pins 2 and 14 as outputs. From the databook.
   
  

  

   Pinout of the 670A triple NAND gate and the 616A quad NAND gate. All three chips have some similarities, such as using pins 2 and 14 as outputs. From the
   
    databook
   
   .
  

  

   One IC with the same silicon as the quad NAND gate is the 670A chip, which
has three NAND gates, each with three inputs (above left).
The diagram below shows how the silicon can be wired to provide this functionality.
  

  

   
    The hypothesized metal layer for the 670A triple-NAND gate.
   
  

  

   The hypothesized metal layer for the 670A triple-NAND gate.
  

  

   The layout for the triple chip above is a bit tricky because the top gate has inputs on
both sides of the power (Vcc) pin.
This creates a layout problem because the power and ground metal runs vertically to the
resistors, blocking metal wiring from one side to the other.
The solution is a "crossunder", a region of silicon that allows a signal to pass under
the metal layer, connecting the inputs on the left to the rest of the circuitry on the right.
This crossunder is visible near the top of the chip.
  

  

   Another chip with the same layout is the 616A dual NAND gate, with five inputs on each gate.
Since this chip has 10 inputs in total (compared to 8 on the quad gate), this chip
uses the two "extra" diodes that I spotted.
If that isn't enough inputs, each NAND gate has an expansion input; by connecting external
diodes to the expansion input, the gate can be made as large as desired.
  

  

   
    The hypothesized metal layer for the 616A dual-NAND chip.
   
  

  

   The hypothesized metal layer for the 616A dual-NAND chip.
  

  

   Some history
  

  

   The history of Signetics is closely tied to Fairchild.
The story of Fairchild's founding is well known: in 1957, eight
engineers—the Traitorous Eight—left Shockley Semiconductor and created
Fairchild Semiconductor.
Hundreds of companies (the "Fairchildren") were started by engineers who left
Fairchild.
Signetics was one of those companies, formed in 1961 and
   
    said
   
   to be the first company to exclusively design and manufacture integrated circuits.
   
    
     2
    
   
   Signetics announced its first product in 1962, a NAND gate that cost $125 (over $1000 in
current dollars).
   
    
     3
    
   
   Not surprisingly, sales were weak.
  

  

   Signetics soon ran short of money, so in 1962, Corning Glass invested $1.7 million for 51%
ownership of Signetics.
Corning Glass may seem like a strange investor, but Corning was more of a high-tech
company than you'd expect, making components such as resistors and
   
    glass capacitors
   
   , and later creating fiber optics.
Moreover, in the early 1960s, integrated circuits were the hot area (much like AI now),
and everyone wanted to get involved.
  

  

   In 1963, the Department of Defense pushed for contractors to use integrated circuits
in new products.
Riding this wave, Signetics became the leading producer of integrated circuits.
   
    
     4
    
   
   However, Fairchild soon introduced a series of DTL chips that competed with Signetics. The
Fairchild 930 series was faster than the Signetics chips and less than half the price,
so Fairchild took much of the market from Signetics and dominated the IC market.
  

  

   Signetics also produced analog integrated circuits.
Signetics is probably best known for creating the
   
    555 timer chip
   
   in 1970, said to be
the world's most popular IC, with billions sold.
   
    
     5
    
   
   Signetics was acquired by Philips in 1975, and then Philips Semiconductors was spun
off as NXP (Next exPerience) in 2006. NXP is currently the #10 semiconductor manufacturer
worldwide, so the heritage of Signetics lives on.
  

  

   For more, follow me on
Bluesky (
   
    @righto.com
   
   ),
Mastodon (
   
    @
    
     [email protected]
    
   
   ),
or
   
    RSS
   
   .
Thanks to CuriousMarc for providing the IC and thanks to TubeTime for finding the databook.
AI statement: Despite the presence of the em dash, no AI was used in the writing of this article (
   
    details
   
   ).
  

  

   Notes and references
  

 




        

      

    
    

        

          
I did a meditation and it sort of changed my personality?

        

        

          Hacker News
        

	

	  www.benkuhn.net
	

        

          2026-11-09 17:23:00
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   In March 2025, I went on a
   
    Jhourney
   
   meditation retreat that was one of the most profound experiences of my life, and deeply reshaped how I related to myself.
  

  

   If you had told my pre-retreat self that this was going to happen, I wouldn’t have believed you. I’d done some meditation before—including a 10-day vipassana retreat—and while it didn’t do
   
    nothing
   
   , I was underwhelmed. I felt pretty resistant to spending that much time staring at the inside of my head: it seemed really hard to actually trust anything I learned that way, because it was such a complicated system. And besides, my brain seemed to work fine the way it was.
  

  

   I’d read some writing by
   
    serious
   
   
    meditators
   
   who seemed to be having a different experience, filled with insights and bliss, but it wasn’t one that I felt particularly drawn to. That much navel-gazing and
   
    wireheading
   
   felt self-indulgent, and anyway they seemed weird enough that whatever they were doing probably wouldn’t work for me.
  

  

   Then, in a moment of life imitating
   
    Bay Area House Party
   
   , we got Jhourney, a meditation retreat startup promising to speedrun you to the bliss part (
   
    tagline at the time
   
   : “Life-changing meditative bliss used to take thousands of hours to learn. We teach it in a week.”) When I heard them strongly recommended not only by the serious meditators I’d been reading, but also by a couple more hard-nosed coworkers, I decided to see what the hype was about.
  

  

  

   Jhourney teaches a style of meditation nominally focused on altered states called jhanas. Jhanas are blissful-feeling states that you can “relax into” if you release enough of what you might call tension or
   
    clenching
   
   or
   
    tanha
   
   , and then focus on an enjoyable open-hearted sensation like smiling, a joyful memory, or feeling care for a loved one. If done right, you can start a feedback loop of enjoying the enjoyment, and end up in a state of deeply absorbed euphoria.
  

  

   I say Jhourney is
   
    nominally
   
   focused on that because the jhanas are actually kind of a Trojan horse for improving your life and relationships, which somehow doesn’t sell as well as wireheading. Jhourney’s unofficial motto is “come for the bliss, stay for the personal growth.” The growth happens because a lot of the tension you’re trying to release in jhana meditation is downstream of repressed or “stuck” feelings, either small ones (“I don’t want to be hearing that sound over there” leading to micro-clenching the head and neck) or big ones (“I can’t let myself feel this sadness or I’ll cry and that would be shameful” leading to tensing the various face and chest muscles that would otherwise be helping you cry). In order to get into jhana states, a lot of people (like me!) end up having to work on untangling knots of emotional clenching, and this usually leads to a lot of growth.
  

  

  

   My first experience of my Jhourney retreat was showing up and being handed an 80-page handbook of meditation instructions.
  

  

   This already blew my mind a little, because I had never read anything about spirituality or emotions that I considered good. The “best” stuff I’d read about the mind was vapid pop-psychology, padding out truisms with engaging fluff until the result somehow became a marketable book. The rest was indistinguishable from astrology—it was never clear enough that I could tell whether it applied to me, which meant it didn’t seem to make falsifiable predictions. As for spiritual writing, it mostly felt like word-association mumbo-jumbo, with authors throwing around words that had the right vibes but that I wasn’t sure they themselves even really understood. Heck, the previous meditation retreat I’d been on had included watching an hour-long recording of the now-dead founder talking about how he could sense quantum vibrations.
  

  

   The Jhourney handbook didn’t have these problems, because it was written by software engineers. It was epistemically conservative and shockingly lucid, completely mumbo- and jumbo-free. To help with the inherently fuzzy language, they explained everything from multiple angles. They gave clear
   
    gears-level
   
   explanations of why they thought things worked the way they did. They even took a detour to explain their teaching philosophy so that students were oriented about
   
    why
   
   they were doing what they were doing. It was masterful pedagogy.
  

  

   Between the written instructions and the teachings from live meditation sessions, pretty soon I could get to a point that felt like the “on-ramp” to a jhana. But every time I got there, I would get stressed and “grabby” about what to do next, and “fall off” the ramp.
  

  

   By the time I got to day 4 of the retreat, I was feeling really frustrated about this, in a way that was starting to loop on itself. I was frustrated that I couldn’t reach jhana, and frustrated that the frustration was making things harder. I tried Jhourney’s recommended way of working with negative emotions, which was a self-compassion meditation. But no matter how much I tried, it didn’t really resonate; I couldn’t cultivate any emotional experience of self-compassion.
  

  

   In fact, I realized I couldn’t remember
   
    ever
   
   having had a real emotional experience of receiving compassion, and that that was probably kind of fucked up.
  

  

   A bunch of my friends were on the same retreat. Since I had no access to self-compassion, of course I used this realization to start worrying that they would judge me for having a hard time meditating because I was fucked up, adding even more layers to the feedback loop of doom.
  

  

   Days 4–6 were pretty bad. Every day Jhourney gave us a survey of “how was your day on a scale of 1-10 with 5 as a normal day?” I rated day 6 a 1.5. (To their credit, Jhourney knew this meant I needed extra help and offered lots of 1:1 time with different facilitators, although none of it made that much difference.)
  

  

  

   At this point, in one of my desperate attempts to think myself out of my feelings pickle, I started thinking a lot about the
   
    metaphor of the elephant and the rider
   
   . The idea is that people usually identify with everything that happens in their mind, but this is actually a confusion; it’s more accurate to think of “you,” the conscious part, as a small human rider perched atop a large lumbering elephant that often does its own thing. The only things that are actually in the rider’s action space are things like “say words to the elephant,” “visualize mental images to the elephant,” “direct attention to a particular aspect of experience,” etc. Everything else—including all emotions and many thoughts—is the elephant’s job.
  

  

   In this frame, the fact that the self-compassion meditation wasn’t working for me wasn’t really “my” fault. Whether the emotional experience of self-compassion happened was up to the elephant, and the only thing “I” (the rider) could do was to keep gently saying the words or doing the technique or whatever, and wait for the elephant to steer, at its own pace.
  

  

   Around that point I decided to give up on the Jhourney curriculum and just do whatever seemed like it would feel nice.
   
    
    
     
      
       ✻
      
      Ironically, Jhourney more or less recommends doing this in various parts of the handbook, but I was too into following rules to follow the part of the rules where they told me to stop following the rules.
     
    
   
   I broke the rule of silence to ask for some reassurance from a close friend who was also on the retreat. When I got back to meditating, I made up a technique for myself where I imagined sending love and compassion to the elephant instead of to “myself.” This turned out to be a cheat code: I immediately felt an outpouring of warmth, and the reassuring things I was telling myself started to emotionally resonate.
  

  

   I really wish I could describe better what happened after that, but unfortunately it was a while ago and involved a lot of subtle mental movements, plus it’s hard to track what’s happening while a chunk of your psyche is liquefying. I remember a sort of sense of “going inside” the feeling of compassion and love for the elephant, having it take up more and more of my attention, and feel more and more deep, rich and meaningful. Then some kind of rush of energy and a full-body frisson that I’ve learned often happens when my brain has rearranged itself.
   
    
    
     
      
       †
      
      I don’t think this strictly qualifies as a jhana by Jhourney’s rubric, because it wasn’t stable and self-sustaining, but it otherwise felt close to how they describe first jhana.
     
    
   
  

  

   When I got up and walked outside, I gradually noticed that the world felt pretty different. I realized that I’d always carried a “refrigerator hum” of subtle body tension that was now gone. Walking around the retreat center looking at the views felt amazing, like I could have spent days just melting into the landscape. The Lipton peppermint tea at the hot drink station tasted unreasonably good. I would sometimes tear up with joy or gratitude for no reason. I felt much deeper care and connection with my friends.
  

  

   Maybe that makes it sound a little gooey and impersonal, like I took a drug that replaced my normal self with a puddle of love or something. The actual experience was the opposite; somehow it felt like this was all happening because it was
   
    easier to be myself
   
   . The care and connection wasn’t coming from some foreign love puddle; it came out because a bunch of psychic gunk had sloughed off and made it easier for the real essence of Ben-ness to shine through.
  

  

  

   And then I
   
    used my newfound mastery of emotions and self-compassion to live happily ever after
   
   flailed around trying to integrate everything back into normal life.
  

  

   One of the big changes I noticed after the retreat was that my emotions got 2–3× more intense. I think this was net positive in the end, but it made coming back to work hard—I had a stressful role managing a large team, and I also needed to catch up from a week of being incommunicado, which was extra stressful. And it wasn’t exactly helpful that suddenly, if someone was annoying on Slack, it would sometimes make me want to shoot flames out my ears.
  

  

   Over the next couple weeks, the intensity settled back down and the changes in my moment-to-moment experience went maybe 80% of the way back to normal (e.g., I stopped spontaneously tearing up in normal circumstances). Some of them stayed, though:
  

  
    
   
  • 
    A lot of my shame/cringe reflex turned into a self-compassion reflex. I used to get super embarrassed by minor mistakes (things like, I don’t know, forgetting to lock a public bathroom door and having someone walk in). Now those things come with a very clear sense of “gosh, what a normal-person type of mistake that millions of other people have also made, it probably didn’t even register for the other person.”
   
    • 
   
  • 
    I became much more easily moved by art. I went from being moved to tears by a poem or piece of music maybe once a year to once a week.
   
    • 
   
  • 
    I stayed much more aware of my more subtle emotional responses. I remember listening to some instrumental folk music I’d probably listened to 100 times before, suddenly noticing that the melody felt deeply nostalgic and then realizing that was two levels further out on the
    
     feelings wheel
    
    than I’d ever felt for music.
   
    • 
   
  • 
    I still felt much less of a need to be distracted or stimulated than before. I used to listen to podcasts at 2× speed whenever I wasn’t fully focused on a task (e.g. if I was doing chores or walking). Now I have no desire to do this, and when I do listen to podcasts, 2× speed feels unpleasant. Similarly, I started to dislike a lot of restaurant food, and to really enjoy very simple home-cooked meals that I would have considered too bland before.
   
    • 
   
  • 
    Friends continued to mention that my body language was different. One noted: “more upright posture, more open shoulders, more fluid and gentle.” Another described me as “‘leaving less,’ as in, spending less time ‘out of the room’ in interactions.”
   
    • 
  

  

   These were great changes, but even better, a bunch of mindset and relational shifts also stuck around.
  

  

  

   Mindset-wise, I guess I’d just say I got feelings-pilled.
  

  

   If you’d asked me what the deal with emotions was before the retreat, I probably would have said something like:
  

  

   

    Positive emotions are nice, although you shouldn’t let them distract you too much from your long-term goals. Painful emotions are responses to stimuli that are part of our evolutionary inheritance, but are largely maladaptive today because we’re in an environment so different from where they arose. Assuming you have good enough self-control not to act out on them, their main effect is to make you dumber, which you should mitigate by not engaging with whatever makes you emotional until you’ve chilled out.
   

  

  

   My new view is more like the following (this is still an oversimplified strawman and reality is a lot messier):
  

  

   

    All emotions are important and beautiful components of unconscious/intuitive cognition.
    
     
     
      
       
        ‡
       
       I do mean
       
        all
       
       , even ones that our culture really doesn’t like—for example, anger is a sign that something you care about is threatened and needs protecting, and fully welcoming it can help bring clarity about what exactly needs protecting and how. If you’re curious to learn more about the beautiful and constructive aspects of negative emotions, I recommend the book
       
        The Language of Emotions
       
       ,
       
        Joe Hudson’s podcast
       
       (search for the emotion you’re interested in), or here are some specific articles summarizing his views on
       
        anger
       
       ,
       
        fear
       
       , and
       
        shame
       
       .
      
     
    
    However, they sometimes create impulses to do things that aren’t actually good ideas. In the process of socializing ourselves not to follow those impulses, we’ve been trained to try to make the emotions themselves go away in painful ways, by repressing them or clenching up around them. Unintuitively, repression and clenching actually cause the emotions to “stick around” in some sort of partially metabolized state, which has negative side-effects, like anxiety, thought-looping, numbness, blind spots, impaired reasoning, bringing up secondary emotions as defenses, etc. A different way of working with these emotions, that’s better for you in the long term, is to figure out how to welcome and accept them. This eventually leads to them feeling less bad, and giving you more impulses that are good ideas and fewer bad ones. But it’s not as simple as “just stop repressing.” Welcoming emotions requires fully feeling them; if they’re strong, that can be too overwhelming to work unless you have a deep felt sense of safety. That safety can be provided in many different ways, e.g. a therapist, friends, some kinds of meditation, etc. If you don’t have access to enough safety, repressing or clenching temporarily might be your best option.
   

  

  

   The main thing that changed my view here was spending days at the retreat paying close attention to my own emotional experience. For example, near the beginning of the retreat, one of the facilitators claimed that thought-looping was usually a sign of a stuck or repressed emotion. I was really skeptical, but then I had several
   
    very clear
   
   experiences of thought-looping around something, going off to a private place to cry about it, and immediately stopping the thought spiral and relating to it differently.
   
    
    
     
      
       §
      
      It was a lot easier to see this clearly on the retreat than in normal life: doing lots of meditation both made it easier to notice my own thought processes, and also faster to “unstick” or welcome the underlying emotions.
     
    
   
  

  

   Similarly, I’d ended a long-term relationship right before the retreat, which I’d felt a lot of internal conflict and self-doubt about. My therapist had often told me things like “if you felt enough of your feelings you’d feel clear about this decision,” which sounded crazy to me at the time (uh, it’s a really hard call and there are a lot of tradeoffs that I don’t know how to weigh!). But on the last day of the retreat I noticed that I felt much clearer that a lot of the things I didn’t like about that relationship were real and important, and felt much more confident in my choice to end it.
  

  

   Of course, I’d already heard plenty of people say things like “you can’t make this kind of decision logically, you have to listen to your heart,” but I never really understood what they were talking about. In retrospect, I just
   
    didn’t have the ability
   
   to do the “listen to your heart” internal move, because
   
    the pipes were clogged by too much repressed gunk
   
   . I wish those soundbites had included a second sentence like “of course listening to your heart can be much easier said than done, so if it feels hard or unclear for you, here are some first steps to get started with, and be prepared for it to take you many hours (or years) to figure out what your heart is trying to say.”
  

  

   This new mindset really shifted the way I related to my emotions. While I still often experience them as painful, it’s much less than I used to, and now I start from the assumption that they’re not “actually” painful or bad, and that the best thing to do with them is to figure out how to accept them, welcome them, and find the wisdom or beauty in them. Overall this feels a lot better—when I run into something stressful or hard, instead of just flailing around not knowing what to do about it, it feels more like I have some kind of sense of direction or overall orientation, which is really comforting and grounding.
  

  

  

   I also noticed that a lot of these ways of thinking about emotional difficulty within myself were also useful metaphors for thinking about emotional dynamics between people. Just like resisting your own emotions is a common coping strategy but ultimately doesn’t work very well, resisting
   
    other people’s
   
   emotions is also a really common but damaging pattern, which I would guess is very involved in a lot of (most?) relational damage. For example, I realized that a big part of the root problem of the relationship that I had just ended was that both of us were missing the capacity to accept a bunch of each other’s emotions, which was something I hadn’t been able to articulate clearly at the time. I now think
   
    practices explicitly focused on welcoming each other’s emotions
   
   are a really valuable tool for nurturing relationships over time.
  

  

   In fact, I started to notice that a
   
    lot
   
   of sticky problems—both in my personal life, but also the type that I ran into as a manager—were partly downstream of people resisting emotions of one type or another. Alice is hard to communicate with, because she frequently monologues about unimportant details, because she wants to prove she understands everything, because she has a bunch of stuck fear/resentment about not being taken seriously. Bob and Clara have a persistent disagreement about strategy, because Clara doesn’t care enough about Bob’s opinion to engage, because Bob was cruel to her once; Clara never complained because she’s avoiding the feeling of having been hurt by it. Dave’s team is underperforming but Erin, the exec sponsor, doesn’t want to manage him out, because she’s scared of the conflict and of making Dave’s reports, who like him, angry.
  

  

   Of course, just because a problem is caused by stuck emotions doesn’t mean that unsticking them is the best way to solve it; but it was still a really useful lens to view what was going on.
  

  

  

   The other shift that stuck around was in my relationships. I made a huge improvement in my friendships, which a few different things contributed to:
  

  
    
   
  • 
    I felt a lot clearer about what I wanted from close friendships—mainly, a strong felt sense of safety and care—and that this felt like a big missing piece in my life.
   
    • 
   
  • 
    I also started getting better at feeling those. With a lot of my shame reflex dissolved, I felt generally safer with people overall—my intuitive predictions about how they’d respond to things I did felt more positive. I also got a lot better at noticing and appreciating the different ways people expressed care for me.
   
    • 
   
  • 
    Because I felt generally safer, I also got more willing to take risks or be vulnerable, which helped build closeness faster. A friend reflected that I seemed more courageous.
   
    • 
  

  

   This also meant that my “friend type” changed—I cared more about emotional connection and less about intellectual connection. Luckily, even though I live in a really heady milieu, I was still able to find a lot of big-hearted people and gradually build up a set of close friends who are wonderful at both. So far, this is the change I’m the happiest about.
  

  

   My dating life changed a bunch as well:
  

  
    
   
  • 
    I started being able to feel much more strongly attracted to people. For example, later that year, I got a crush on someone that was stronger than any crush I’d had in high school.
   
    • 
   
  • 
    I had a run of anxious-attachment-ish experiences, which I’d never had before, although they got way milder over time.
    
     
     
      
       
        ‖
       
       I’m not totally sure what was up with this; I think it partly had to do with calibrating to the new level of attraction I could feel.
      
     
    
   
    • 
   
  • 
    The extra safety and courage I mentioned above were helpful in dating too: I got much more comfortable with communicating tricky things or being in weird situations (e.g. ones outside the standard script of “meet someone on an app, go on some dates, become exclusive”). A friend commented that it seemed like I had more degrees of freedom.
   
    • 
  

  

  

   These changes have been really wonderful overall, but also kind of intense. Becoming much more emotionally aware solved a bunch of my problems, like wanting deeper friendships or not understanding why my relationship was unsatisfying. But it turns out winning that boss fight just made all the enemies level up. My old problems got replaced with horrible new problems, like that sometimes my newly deep friends and I would have conflicts, or that I would be more into the person I was dating than they were into me.
  

  

   The part of my life where I feel the most mixed about the impact is work. About six months after my retreat, I got a pretty bad case of burnout and left my role managing a big team for a significantly less ambitious IC role. I don’t think the retreat was the main cause of my burnout—the main cause was that I didn’t have enough background in the area I was managing to have the type of impact that I wanted to, with a side helping of some difficult working relationships. But it turns out my new psyche had also gotten worse at repressing or avoiding emotion, and that made everything harder.
  

  

   I think of repression as the emotional equivalent of
   
    technical debt
   
   or
   
    deferred maintenance
   
   : a way of avoiding an immediate cost, in this case feeling uncomfortable feelings, in exchange for paying a higher cost later to clean it up.
   
    
    
     
      
      Like tech debt or deferred maintenance, sometimes repression or avoidance can be the right strategy, if you’ll have more resources to deal with the problem later!
     
    
   
   My role exposed me to a constant stream of low-grade painful things, like people being disappointed or annoyed at me, me being disappointed or annoyed at other people, projects not going well, office snacks being replaced with worse snacks, and so on. With less ability to avoid or repress, I had to feel more of them fully as they came up, and that was really draining. It also required enough time and attention that I had to defer a bunch of maintenance on my personal life.
  

  

   Even now that I feel like my energy levels have mostly recovered, I’m still not sure whether I want to go back to the center of the vortex. It’s not just that I would have to start deferring maintenance again; I’m also much more aware of a lot of maintenance I’d
   
    already
   
   deferred and really want to clean up—things like investing in friendships, like I mentioned above.
  

  

   If I were only working toward my personal growth and happiness, I’d say this change was clearly good. My life feels much richer and more whole, and taking a less ambitious role forced me to release some layers of ego attachment to having a “shiny” job or career, which was deeply freeing. But… I also care a lot about my impact on the world, and I think
   
    the next few years will probably be a critical period
   
   where my work could be especially high-leverage. From that perspective, it’s sad to feel resistant to maxing out on work right now.
  

  

  

   I feel pretty unsure about what to take away from all this. Here are some disconnected reflections.
  

  
    
   
  • 
    I would never have said that I had a problem with self-compassion or self-esteem before doing this retreat, because I was able to say the right self-compassionate words when I directly asked myself things. But from my point of view afterwards, it’s clear that I did have a big self-compassion problem; even though I could say the words, I wasn’t really feeling them or acting like they were true. Having the actual embodied experience and habits of self-compassion is the closest I’ve come in real life to
    
     The Vitamin
    
    .
    
     
     
      
       
        ✻✻
       
       “My deepest darkest fantasy is that I collapse on the street and I am rushed to the hospital. They perform a bunch of tests and find out I am severely deficient in some kind of vitamin. Then I start taking the vitamin and I become the happiest cleverest person alive because all my problems were caused by this one deficiency."
      
     
    
   
    • 
   
  • 
    Jhourney is doing something really cool and is way better than most/all other meditation retreats on several axes (amount of support available, pedagogical excellence). That said, you probably shouldn’t expect to have
    
     this
    
    life-changing of an experience; I would guess I had something like a 95th-percentile-plus outcome in terms of long-term effects. I still think it’s awesome as an introduction to both meditation and embodied emotional awareness.
   
    • 
   
  • 
    I feel like I got really lucky on timing: if the retreat had ended one day earlier, I don’t think I would have gotten to the life-changing part. That freaks me out a lot.
   
    • 
   
  • 
    At first I concluded from this that I should get super into meditation. Then I did two more retreats (another Jhourney retreat and a Dustin DiPerna introduction to mahamudra retreat) and neither one of them had nearly as large of an effect. The second Jhourney retreat was really helpful in reinforcing my daily practice, and I do think a daily meditation practice was helpful in stabilizing the changes that became permanent, but I’m not even totally sure about that.
   
    • 
   
  • 
    Jhanas are definitely real. Also, it was kind of wild hearing somebody tell me something that sounded totally fake (“achieve bliss on demand using nothing but your brain”) and then back it up with an 80-page engineering manual and meticulous data on success rates. Overall this made me much more likely to believe that various other types of “woo” phenomena are real, at least in the sense that people are accurately describing their experiences. (I still believe the universe runs on physics, but a lot of woo things have physics-compatible explanations, especially if you buy that people’s intuitions can sometimes do spooky things.)
   
    • 
   
  • 
    I described this as “chang[ing] my personality” in the title, but I don’t want to oversell the magnitude. I do have a lot of conversations where someone asks me “so how come you’re so <like X>” and I tell them “I did this weird meditation retreat a couple years ago.” But also, there are a lot of different aspects of personality, and even though a bunch of those completely changed for me, most of them are still the same, so I’m still very similar to my past self in an absolute sense.
   
    • 
   
  • 
    What flags should tip you off that you should maybe be staring into your emotions more? Here are some things that I think might be clues (a lot of which described me, in retrospect):
    
      
     
    • 
      You often get stressed and stuck in thought loops
     
      • 
     
    • 
      You’re easily annoyed or frustrated
     
      • 
     
    • 
      You have too much scarcity mindset—you often worry this is the best job or relationship or whatever that you’ll ever have, in a way that’s not justified by the fundamentals
     
      • 
     
    • 
      You seek out a lot of distraction or stimulation; it’s not very enjoyable to just exist in the present
     
      • 
     
    • 
      You feel a lot of internal conflict or uncertainty about what you want
     
      • 
     
    • 
      There are parts of yourself that you really don’t like or wish were different
     
      • 
     
    • 
      You feel some missing depth, richness, or meaning in your life but can’t put your finger exactly on what
     
      • 
    
    
   
    • 
  

  

   I’m also just left with a lot of questions:
  

  
    
   
  • 
    Was this set of experiences… good?
    
      
     
    • 
      I’m really confident that it will be good for my own long-term life happiness. But the timing meant that I feel less willing to sign up for intense work during what might be one of the most critical periods for humanity, which feels bad even if the change was positive. I feel kind of unsure how to balance these.
     
      • 
     
    • 
      My shoulder
      
       Jeremy Bentham
      
      says I should have just kept
      
       playing push-pin
      
      . My shoulder, uh…
      
       deva?
      
      says if I follow my heart my impact on the world will be higher, even if it’s less predictable or legible. I don’t really feel like I buy either of these.
     
      • 
    
    
   
    • 
   
  • 
    It seemed like before this I was in a personality
    
     attractor basin
    
    with a lot of numbing and repression. How exactly did this happen, and more importantly, how can I/we avoid having it happen to as many people in the future?
    
      
     
    • 
      I have some sort of fuzzy leads on this (e.g. when I was young it was really easy to make me cry so I got picked on a lot in school), but not a particularly complete picture (e.g.: does this happen to everyone who has that experience? If not, what makes the difference?)
     
      • 
    
    
   
    • 
   
  • 
    Mechanistically, what did the elephant meditation do? Why did it work so suddenly and create such a lasting shift? (Was that in fact what was responsible for most of the lasting shift? How much of it was instead about what I learned at a cognitive level?)
   
    • 
   
  • 
    Is the glowy, “easier to be the essence of Ben” state that I ended up in right afterwards something that can be stabilized (or have aspects stabilized)? If so, how?
   
    • 
   
  • 
    More generally—where do I go from here? I’m convinced that doing the right type of introspection or meditation type thing for a week can unlock amazing things, and it feels like there are more amazing things out there to unlock, but I wish I had a better way of navigating towards them than semi-randomly trying things.
   
    • 
  

  

  

   A draft reader asked what I would tell my past self, or someone like me, about this arc. Ultimately, I’d boil it down to:
  

  
    
   
  • 
    
    
     There are probably a bunch of feelings that you’re refusing to welcome into your experience, and this is probably involved in a bunch of the things that are unsatisfying about your life and relationships.
    
    
   
    • 
   
  • 
    
    
     You can improve this by gradually, in a safe context, paying loving attention to the uncomfortable parts, from a place of wanting to know and care for yourself rather than to fix yourself.
    
    
   
    • 
   
  • 
    
    
     When that’s hard, remember that it’s not your fault. You’re just the rider; elephants gonna elephant. Let it go where it needs to and keep loving it as best you can.
    
    
   
    • 
  

  

  

   
    Thanks to
    
     Alex Allain
    
    ,
    
     Catherine Olsson
    
    ,
    
     Elena Lake
    
    ,
    
     Jess Ocean
    
    ,
    
     Rahul Dalal
    
    , and
    
     Sasha Chapin
    
    for feedback on a draft of this post.
   
  

 




        

      

    
    

        

          
A year after the 100% AI mandate nobody understands our code

        

        

          Hacker News
        

	

	  www.reddit.com
	

        

          2026-11-09 17:19:12
        

        

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   You've been blocked by network security.
  

  

   

    To continue, log in to your Reddit account or use your developer token
   

   

    If you think you've been blocked by mistake, file a ticket below and we'll look into it.
   

   
  

 




        

      

    
    

        

          
Two apps one process

        

        

          Lobsters
        

	

	  andersmurphy.com
	

        

          2026-11-09 17:14:10
        

        

          
            

          
          

            Comments...
          

        

        

          
Original Article

          

 

  

   

    
   

  

  

  

   
    So what if you can handle thousands of concurrent users per core? Even the front page of HN gets you what? 100 concurrent users on a good day?
   
  

  

   More like 30.
  

  

   
    Exactly! Most successful apps have like what 10 or 20 concurrent users at any given time? This is basically academic for most projects. What does performance give you other than knowing that your app won't need to scale past a single server? Pointless!
   
  

  

   Well what if you could run multiple apps in one process?
  

  

   
    Isn't that the same as a bunch of apps behind a reverse proxy?
   
  

  

   No. It's not. Separate processes have to compete for OS resources, have their own thread pools, schedulers, heap, GC, caches and so on. Each process needs to be sized relative to the other apps running on the system.
  

  

   But, in a single process you can size the process for the machine and then run an arbitrary number of apps in that process. If the apps share a process, they can share all sorts of things: a single JVM, GC, caches, buffers, http server, HTTPS certificate management, batching, game loop etc. You'd eliminate thread contention between apps. This lets you scale further with less resources!
  

  

   Performance lets you run as many apps as you want in that one process.
  

  

   
    ...
   
  

  

   

    Disclaimer: all my writing and code is handcrafted by me. By the end of this you may wish it wasn't.
   

  

  

   Some numbers
  

  

   If you have multiple JVMs you duplicate a bunch of fixed costs:
  

  
    
   
  • 
    Separate heaps
   
    • 
   
  • 
    Separate JIT
   
    • 
   
  • 
    Separate GC
   
    • 
  

  

   If you have multiple HTTP servers you duplicate:
  

  
    
   
  • 
    event loop threads
   
    • 
   
  • 
    byte buffers
   
    • 
   
  • 
    queues
   
    • 
  

  

   If you have multiple framework engines you duplicate:
  

  
    
   
  • 
    html buffers
   
    • 
   
  • 
    render threads
   
    • 
   
  • 
    fragment caches
   
    • 
   
  • 
    queues
   
    • 
  

  

   All of this adds up to more memory, more threads and more contention. If you own all your app and don't need the isolation a processes give you, then it can be a big performance win to have one JVM, one http server, and one framework engine.
  

  

   
    Where were the numbers?
   
  

  

   
    X * n
   
   where
   
    X
   
   is you fixed cost for the above and
   
    n
   
   is your number of apps. If all of the above takes 500MB, then four apps is an extra 1.5GB.
  

  

   What is an app?
  

  

   
    A miserable little pile of secrets
   
  

  

   Indeed. If you think about it an app at it's simplest is a domain, a database and some routes.
  

  
(def app
  {:domain   "example.andersmurphy.com"
   :db       {:name          "gol.db"
              :migrations    migrations
              :pragma-writer {:cache_size 15625}
              :pragma
              {:cache_size 2000
               :page_size  4096
               ;; 1GB
               :mmap_size  1000000000}}
   :routes   #'routes
   :batch-fn #'batch-fn})


  

   HTTPS certificate management with Clave
  

  

   
    But, my reverse proxy handles HTTPS certs and stuff! Where is your god now?
   
  

  

   Yes certs are a pain. But
   
    Clave: Automatic HTTPS certificate management and renewal via ACME, implemented in pure Clojure with minimal dependencies
   
   exists. I use it with aleph. But, it also works with jetty and it's simple to extend to other servers.
  

  
(clave-aleph/start-server router
  (merge
    config
    {:http-versions             [:http2 :http1]
     ::clave-aleph/http-options {:port 80}
     ::clave-aleph/config
     {:domains (mapv :domain apps)
      :issuers
      [{:directory-url
        "https://acme-v02.api.letsencrypt.org/directory"
        :email email}]}}))


  

   So no reverse proxy needed.
  

  

   Bundling our apps
  

  

   To bundle our apps we import them as dependencies into a separate project who's only purpose is to configure and start the server.
  

  
(ns app.main
  (:gen-class)
  (:require
   [hyperlith.core :as h]
   [billion-cells.main :as cells]
   [billion-checkboxes.main :as boxes]
   [game-of-life.main :as gol]
   [clj-async-profiler.core :as prof]))

(defn start-app! [& {:keys [mode]}]
  (h/start-server!
+   {:apps               [cells/app boxes/app]
     :tick-ms            100
     :render-buffer-size (* 64 16384)
     :email              (h/env :email)
     :mode               mode}))

(defn -main [& _]
  (start-app! :mode :prod))


  

   So adding a new app is as simple as importing it and adding it to the list of apps:
  

  
:apps [cells/app boxes/app gol/app]


  

   We can then build this project as an uberjar and
   
    scp
   
   it to the server.
  

  

   Deployment
  

  

   
    Well this is nice and all, but whenever you deploy an app, you restart the process. DOWNTIME! UNACCEPTABLE!
   
  

  

   Here's a gif of me deploying the jar to production:
  

  

   deploy gif
  

  

   If a deploy is indistinguishable from network blip did the app really go down?
  

  

   Conclusion
  

  

   That's it. We've reduced the overhead and cost of deploying a new app to zero.
  

  

   Code
   
    can be found here
   
   . All three apps are running on the same JVM, on the same 10$ VPS ,
   
    here
   
   ,
   
    here
   
   and
   
    here
   
   .
  

  

   
    Thanks to
   
   Everyone on the
   
    Datastar discord
   
   who read drafts of this and gave me feedback.