HNHacker News
TopNewBestAskShowJobs

peter_d_sherman

19,053 karma · joined September 16, 2014

Programmer, Student Of Law, Entrepreneur & Comedy Writer.

Open Source, Open Hardware, Transparency & Free Speech enthusiast.

peter.d.sherman@gmail.com www.linkedin.com/in/peter-sherman-a6107a5 https://x.com/peter_d_sherman

"The true knowledge consists of knowing that one knows nothing..."

- Socrates

submissionscomments
peter_d_sherman··on HERMES radio enables voice and data communication over vast distances
>How does HERMES connect remote locations?

Peter Bloom: We use the ionosphere as our satellite—or mirror—which helps us move information, voice, and data over really long distances. We’re using small radios that put out about 20 watts of power, and we can pretty reliably do 400 to 600 kilometer links between two radios."

That is some amazing distance for a very small amount of power!

peter_d_sherman··on Microsoft killed FoxPro in 2007. Anyway, here's FoxPro revived
Microsoft should open-source FoxPro, at least some version of it, because as of 2026, it has no commercial viability (no ability for it to make the company money) compared to say SQL Server, Access and/or Visual Basic with the appropriate back-end database drivers. If Visual FoxPro V9 (2007) is too late because there are unexpired patents or other issues, then Microsoft should open-source an earlier version.

Even open-sourcing FoxPro 2.6a for DOS (the last DOS version, August 1994, > 30 years ago) would be better than open-sourcing no FoxPro version.

Fundamentally, FoxPro, at its core, is 4 things:

1) It's own low-level database engine

2) It's own SQL parser/interpreter/engine sitting on top of #1.

3) Simple (but very data-aware of the underlying data!) scripting language (based on dBase, referred to as "xBase" -- or more specifically the FoxPro dialect of xBase) sitting on top of #1 (except for the SQL commands, SELECT, INSERT, UPDATE, DELETE, etc., which sit on top of #2)

4) Form / GUI / Data-entry and Data-search Form Designers that exist on top of #1, #2 and #3. Basically a primitive (although very functional and elegantly simple) windowed App building environment.

Now, all of those 4 things could be replaced and/or outsourced to other open-source projects...

For example, to read/write/index/seek in FoxPro database files (the low-level database engine):

https://github.com/MPSystemsServices/CodeBase-for-DBF

I'm not sure if CodeBase comes with its own SQL engine/parser -- but if not, SQLite has a pretty good one which could probably be used with some modifications. If not, ANTLR has various SQL grammars for it floating around on the net (here's a quick blog post of someone using ANTLR to create a query language: https://markandrewperry.medium.com/using-antlr-to-create-a-q...)

For the scripting language, any scripting language could potentially work, but special attention should be paid to the way FoxPro variables are aware of data in underlying open tables in the current work area (SCATTER and GATHER commands and how they work, etc.), which is one of the unique features of FoxPro. (Also, for command / line / expression evaluation, you'd probably want to use or at least know about Dijkstra's Shunting Yard Algorithm: https://en.wikipedia.org/wiki/Shunting_yard_algorithm)

For the GUI / Form designers, well, any data-aware form-designing graphical toolkit could work, but of course, FoxPro has/had its own nuanced "flavor" of these.

Generically speaking, FoxPro is/was a database engine, SQL engine, very-data-aware scripting language and form/gui/app designer -- all rolled into one package.

I'd love to see an app where all of these components are open source, where there are clear interfaces between those components (separate compilation options for codebases, depending on which components you want), where the original FoxPro/dBase/xBase scripting language is used (because it was great!) and where any underlying database engine and/or SQL engine could be "swapped out" for any other (i.e., SQLite, Postgres, etc.)

Anyway, FoxDevStudio looks interesting in this space!

peter_d_sherman··on Measure internet censorship
Related:

Quack: Scalable Remote Measurement of Application-Layer Censorship:

https://www.usenix.org/system/files/conference/usenixsecurit...

Global Measurement of DNS Manipulation:

https://www.usenix.org/system/files/conference/usenixsecurit...

Reachability index of Internet blockade circumvention tools:

https://explorer.ooni.org/circumvention

Psiphon:

https://forge.psiphon.ca/en/what-is-psiphon

peter_d_sherman··on Search Engine that de-ranks Bot Popup and Cookie Popup websites?
I'd like a search engine that de-ranks any website where any of the following things are present:

1) There's a no-bot verification screen

2) There's a cookie acceptance popup

3) There's a paywall prior to the content.

4) There's a sign-in page prior to the content.

5) There's anything else, any other kinds of popups or re-routes or "you-can't-have-your-content-directly-after-your-click" that prevents a sub-ms response between clicking on a link and getting to the actual content.

I want a Search Engine like that.

Like the Internet of old.

De-rank any and all ensh-ttified websites from the search results at the user's request.

Give the user that option.

I want a Search Engine like that...

peter_d_sherman··on Building the fastest LLMs: why we're starting with diffusion
>"The evidence for each of these properties is already public. On raw speed, parallelism gives diffusion decoding headroom that serial generation cannot reach: Fast-dLLM, an NVIDIA-led study, showed that decoding many tokens per step delivers up to a 27.6× throughput improvement on open diffusion models with minimal accuracy loss - from training-free acceleration alone.

Bidirectional context also closes a significant capability gap. Autoregressive models suffer from the reversal curse: trained that "A is B", they fail to infer "B is A" - GPT-4 answers 79% of forward questions about celebrity relationships but only 33% of the reversed ones. LLaDA, an 8B diffusion model that attends to the whole sequence at every step, breaks the pattern, surpassing GPT-4o on reversal reasoning."

This is an interesting aspect of Autoregressive Vs. Diffusion models, that is, "can they get reversed reasoning correct?"

One aspect of this, of course, is the philosophical one... that is, if a cup is half empty, it is also (equal-and-oppositely!) half-full!

If a fact, fact A is related to another fact, fact B in some way, then there equal-and-oppositely must exist a reverse relationship (sometimes called an inverse relationship, sometimes called a reciprocal relationship, sometimes called a complementary relationship -- there are many names for it!) between fact B and fact A, when reasoning starting with fact B as the starting point.

Future AI's, if they are to truly understand the physical universe (reason absolutely correctly about it, all of the time, a must for subjects like Math and Physics), must understand reverse relationships.

That's why the above quote, from the above article, is interesting...

That's also why AI models based on Diffusion -- may be worth studying, or studying more about, as the case may be!

peter_d_sherman··on Bend – a language that blocks AI mistakes via proof and runs on GPUs
Hmmm, this is interesting, because one might think of Software as a series of lower-level "laws", that is, specified in terms of the lines of the source code itself in whatever programming language it was written in, and (more recently, in the AI coding era) a set of higher-level, specified in human language "laws" that a coding assistant AI must also take into consideration (in addition to the code itself) when working on the code.

Because it is never 100% guaranteed that an AI produces the right answer or the right set of changes, the need for an intermediary level of "laws" between the low level and the high level arises, and that is the domain occupied by mathematical and programmatic Proof Checkers, aka "Proof Assistants" aka "Theorem Provers" (Lean, Rocq, Agda, Idris, Metamath, F*, etc., etc.) and the corresponding software harnesses that drive them...

Bend is one example of what's emerging in this space.

As one of the contenders in this emergent space, Bend looks like it should be worth following...

peter_d_sherman··on Dan Alistarh's Website (IST Austria Distributed Algorithms and Systems Lab)
Related:

https://huggingface.co/ISTA-DASLab

https://github.com/IST-DASLab

https://ist.ac.at/en/research/alistarh-group/

peter_d_sherman··on Wafer-Scale Superconducting Transistors Cut Cryo Cables
>"They fabricate their superconducting transistors on a 6-inch (150-mm) silicon wafer. Their CMOS-compatible process involves laying a graphene channel upon the wafer and shaping three electrodes from an aluminum-based superconductor. Two of these electrodes touch the graphene channel to create an aluminum-and-graphene Josephson junction. Then, controlling the voltage through the third electrode—the gate—can change the critical current or switch the superconductivity on or off.

Graphene isn’t normally a superconductor, but with the right conditions, the electrodes can “leak” their superconductivity into the graphene.

The researchers spent years fine-tuning their process to achieve those conditions. Their device’s geometry, materials, and engineering had to be just right."

Isn't that interesting! Graphene, or at least a very small 150nm-scale "nano surface" of Graphene becoming a superconductor under the right conditions! It'll be interesting to see where that goes in the future...

peter_d_sherman··on The scourge of x86 emulation
>"These two models are basically the two extremes of the spectrum; where ARM is the most relaxed, allowing significant hardware optimizations; and x86 is the most strict, enforcing a very strong coherency model that doesn’t allow a lot of room for optimization. [...] The best way to explain how the differences in memory models work is to start with how x86 handles this. With TSO being very strict in how it operates, the programmer can assume that when a memory store occurs, that this will be coherently visible to all other processors in the system. The weak memory model that ARM has is a bit less intuitive about how it operates. By default the regular memory loads and stores that ARM uses aren’t strictly coherent across processors in your system, allowing the CPU to operate more efficiently most of the time. When a store instruction executes, that piece of memory (the cacheline) isn’t immediately visible to other processors in the system. Saving on precious power and efficiency because it’s expensive in hardware to invalidate other core’s cachelines, or allow them to snoop another processor’s caches."

First of all great article! It's an absolute must-read for anyone who would design a CPU, GPU, NPU, xPU, Compiler, or Operating System.

It's an absolute must-read for any low-level Programmer.

We can almost think of these different ways of doing things (x86 vs. ARM) as a "battle of virtues" -- on the one hand, with x86, the low-level programmer gets guaranteed memory read consistency across all cores when any one core executes any single instruction which writes something to memory.

Virtuous! But, at the expense of constantly running a whole lot of extra circuits per instruction which use power and generate heat. It's necessary, damn necessary, for some instructions though!

But it isn't necessary for all instructions that write to memory, because whether it's necessary or not is determined by a lot of factors -- the program it's in, is the memory address used for shared communication or a shared data dependency between cores, etc., etc.

So, on the flip side, ARM uses what is called a "relaxed" model.

The low-level programmer gives up the x86 memory-consistent-across-all-cores-guarantee for every memory write, and now has the responsibility to issue additional instructions to get other cores to see that updated memory.

On the one hand, you've got more hardware complexity to make software simpler, on the other, you've got more software complexity to make hardware simpler.

Which is the "right" solution? Well I don't know. Both have their plusses and minuses from either side of the equation, hardware designer or low-level software designer. Still, it is a great issue to be aware of, and even though some posters had some good-faith and possibly very valid critiques of the article, I liked it! It's an important issue to be aware of, for hardware and software designers alike.

peter_d_sherman··on Accurate Models of AMD Matrix Cores
>"Features of matrix multipliers differ across vendors and architectures of the same vendor [...] As a result, reproducibility of small matrix multiplier results [differences] across devices is not possible and cannot be achieved by software control. Implementation details of matrix multipliers are not documented, making it difficult to interpret discrepancies in the computed results."

I'm guessing (but not knowing) that small subtle differences in matrix multiply across different vendor's architectures (and product generations of an individual vendor's architecture) is responsible for a good portion of software crashes when trying to run a local LLM on a different architecture or with a different stack (ROCm vs. CUDA, for example) than the ones it has been explicitly tested on.

As such, this marks a rather significant problem for the future, which can basically be stated as:

There needs to be a standard matrix multiply specification (much like IEEE-754 is/was for floating point operations) that all future vendors of AI accelerators (any GPU, CPU, NPU or IC manufacturer whose circuits implement matmul) adhere to, such that the matmul of one vendor is exactly and precisely compatible with the matmul of another.

Hardware vendors of course, are free to compete in terms of speed, power efficiency, number of matmul engines on a given piece of silicon, parallelization optimizations, etc., but the basic matmul operation should be exactly and precisely compatible across vendors and across future product versions.

Step 1: We need a spec for this... (Maybe IEEE is already working on one? If so, that's a good step forward!)

Step 2: Hardware vendors need to implement it, to be universally compatible in all of their IC's that use matmul, in the future...

peter_d_sherman··on Sony's First Computer – The SMC-70 from 1982 [video]
This has to be one of the most clever old/vintage computer things I've seen for awhile...

Basically, instead of a rigid hardware bus (fixed metal traces on a PCB motherboard), it uses a soft, flexible multi-pin cable with multiple connectors -- as its bus!

Brilliant!

Yes, these would be frequency-limited because they couldn't be designed with the same precision as the buses on the circuit boards today, but for older computers running in the lower Mhz regime, this would not have been a problem.

And yes, you could argue that the S-100 bus had cable versions of it, and SCSI was a bus extension, and both of these would be valid arguments, but I've never thought of using a soft multi-pin cable as an actual low-Mhz early computer bus -- until watching this video.

Anyway, great video!

peter_d_sherman··on A Passive Soft-Switching Snubber for PWM Inverters (2004) [pdf]
>"To reduce switching stresses, losses, and electromagnetic interference (EMI), soft-switching techniques have been developed for power converters since the 1970s [1]. There are many topologies of soft-switching inverters [1]–[10], such as resonant dc link, resonant snubber, and zero-current transition inverters [8]. Soft-switching inverters can be grouped into two main categories: resonant dc link and resonant snubber. The resonant dc link provides zero dc-link voltage or current intervals to all phase legs during switching instants, whereas the resonant snubber diverts current from and/or provides zerovoltage intervals to each main device at switching instants. The active clamped resonant dc link converter [1] and the auxiliary quasiresonant dc link converter [2], [10] are examples of resonant dc link inverters. Auxiliary resonant snubber inverters such as the auxiliary resonant commutated pole (ARCP), zerovoltage transition, and resonant snubber inverters [9] belong to the second resonant snubber category."

What it is: A "snubber" (terrible terminology btw, IMHO, but we'll go with it for now!) basically adds a resonant circuit part to a previously non-resonant switch or switched circuit, such as those common in switched power supplies and inverters.

Basically, the "switch-on, switch-off, repeat" circuits that drive electrical transformers of all sorts.

Well, take that, add a resonant circuit component to it (which basically "smooths" the immediate presence of a voltage during the on phase and the immediate drop of a voltage to 0 during the off phase) and that's what "snubber" is.

I should point out that There are power snubbers that do the same thing but for current, i.e., snubbers of one type for voltage, snubbers of another for current, but the basic idea is the same -- smooth things out, smooth the waveform out -- don't allow immediate (instantaneous) dips or spikes, smooth it out over milliseconds, microseconds, nanoseconds, whatever the frequency of the waveform requires...

Anyway, that's a "snubber" (an added resonant circuit component).

Added to power supplies and inverters and transformers of all sorts, once resonance is established, heat/heating/heat losses drop, and power conversion efficiency increases rather significantly.

Switch/switching circuit life is also extended.

Anyway, it's a fascinating topic!

peter_d_sherman··on Tree Calculus
Second Addendum:

Böhm Trees:

https://en.wikipedia.org/wiki/B%C3%B6hm_tree

Seem like they might be related to this discussion in some way...

peter_d_sherman··on The GDR and Vietnam: From Fake Coffee to Coffee Empire
>"So that only left socialist countries to source coffee from, but the Soviet Union had decided to stop its coffee exports to the GDR in 1954. So the GDR regime had to buy it wherever it could and whatever the cost, spending around 150 million West German marks a year to do so. They also relied on West Germans sending their eastern pals and relatives coffee, which covered around a fifth of demand. For a long time that worked sort of okay.

Coffee wasn’t always easy to get hold of. You might have to visit several shops or draw on some connections to get hold of some, but it was still proper coffee and by and large available. Then the coffee crisis of 1977 hit the world."

Compare (cf.) and contrast with the U.S. of 2026 -- there's like what, 7 competing coffee shops on every block of the downtown of every major city, and in Seattle that number is at least doubled, to at least 14... in other words, we have no shortage of coffee in the U.S., quite the opposite!

(Possibly we have too much coffee, if such a thing is possible, and apparently, it is! :-))

peter_d_sherman··on XLS: Accelerated HW Synthesis
>"XLS enables the rapid development of hardware IP that also runs as efficient host software via "software style" methodology. An XLS design runs at native speeds for use in host software or a simulator, but that design can also generate hardware block output -- the XLS tools' correctness ensures (and provides tools to help formally verify) that they are functionally identical."

The ability to run and verify hardware designs quickly in software simulators is the key to rapid iteration of hardware designs, which is the key to more robust hardware, faster.

For that reason, XLS should be worth watching in this space...

peter_d_sherman··on When LLM judges agree, should we believe them?
Observation: A panel of Judges (multiple Judges), whether it's multiple AI's or not, is fundamentally -- a Jury!
peter_d_sherman··on A 386 PC for Your RP2350
>Holy cow, a 386 with VGA and SoundBlaster on a $1 MCU?

The right software -- really does add value(!) to (let's-just-say-it-isn't-an-nVidia-GB300!) hardware, now doesn't it? :-)

I don't know about anyone else -- but I'm sold!

The value proposition on this one is truly awesome!

peter_d_sherman··on Tree Calculus
>Great notes!

Thank you!

>I think it’s also worth noting that Barry Jay has a particularly strong vantage point for unearthing this particular foundational candidate. First, his advisor was Joachim Lambek, who’s responsible for adding Category Theory in the Curry-Howard-Lambek correspondence.

Curry-Howard-Lambek correspondence is a very important point, I'm glad you brought it up!

>If one looks at Barry’s body of work over his lifetime, it’s no surprise it would culminate into an elegantly beautiful system capable of self-reflection.

No, it's not surprising indeed!

>I think his 2025 PEPM paper did a great job explaining the ideas to a regular programmer / wannabe academic like myself: https://github.com/barry-jay-personal/typed_tree_calculus/bl...

Excellent link!

Random thought:

From the paper: "The operator [Triangle] (pronounced "node") is a ternary operator)..."

I wonder if Tree Calculus (and/or binary trees in general!) could be related to, and/or applied to the Ternary Tau and/or the Balanced Phinary number systems:

https://neuraloutlet.wordpress.com/tag/ternary-tau-system/

https://en.wikipedia.org/wiki/Balanced_ternary

peter_d_sherman··on Tree Calculus
Addendum: "Tromp Diagrams" (aka "Lambda Diagrams") are potentially related to Tree Calculus, and should be added to the list above, at the very least as a visualization tool for Lambda Calculus, and potentially as an additional visualization tool for other compatible systems:

https://tromp.github.io/cl/diagrams.html

Related Video:

2swap - "What is PLUS times PLUS?"

https://www.youtube.com/watch?v=RcVA8Nj6HEo

(An excellent example of how Lambda/Tromp Diagrams can be used to visualize Mathematics (i.e. application of a function to another function, recursive functions, etc., as line drawings with horizontal and vertical lines -- which almost look like Sanskrit...))

peter_d_sherman··on The Coming War on General Computation (2011)
>"((1012.5)) So today we have marketing departments who say things like "we don't need computers, we need... appliances. Make me a computer that doesn't run every program, just a program that does this specialized task, like streaming audio, or routing packets, or playing Xbox games, and make sure it doesn't run programs that I haven't authorized that might undermine our profits". And on the surface, this seems like a reasonable idea -- just a program that does one specialized task -- after all, we can put an electric motor in a blender, and we can install a motor in a dishwasher, and we don't worry if it's still possible to run a dishwashing program in a blender. But that's not what we do when we turn a computer into an appliance.

We're not making a computer that runs only the "appliance" app; we're making a computer that can run every program, but which uses some combination of rootkits, spyware, and code-signing to prevent the user from knowing which processes are running, from installing her own software, and from terminating processes that she doesn't want.

In other words, an appliance is not a stripped-down computer -- it is a fully functional computer with spyware on it out of the box.

(audience applauds loudly) Thanks."

Some excellent observations by Cory Doctorow!

Related:

https://en.wikipedia.org/wiki/Enshittification

"A Day in the Life of an Ensh*ttificator":

https://www.youtube.com/watch?v=T4Upf_B9RLQ

peter_d_sherman··on ZLUDA – Drop-In Replacement for CUDA on Non-Nvidia GPUs
Related:

ZLUDA update Q1&Q2 2026:

https://vosen.github.io/ZLUDA/blog/zluda-update-q1q2-2026/

peter_d_sherman··on Tree Calculus
>"Tree calculus is a minimal, modular, Turing-complete and reflective calculus."

This makes it a candidate for the foundation of all of Mathematics...

Other candidates in this space include such things as Category Theory (everything reduces down to a single operation called a 'composition'), Lambda Calculus (everything reduces down to function application), Formal Rewriting Systems (aka Symbol Substitution / Post Canonical System / Markov Algorithm -- everything reduces to a single operation: string rewriting, matching a pattern of symbols and replacing it with another. Turing Machines, for example, exist within this space...), Homotopy Type Theory (aka HoTT: Paths as Transformations, statements of equality (a = b) are not static truth values; they are paths (or continuous transformations) living in a higher-dimensional space. Logical proofs, algebraic manipulations, and geometric deformations are all unified under the concept of "path induction." Proving that two mathematical structures are equivalent is equivalent to finding a continuous path of transformation between them.")

That's some of them, others include such things as Turing Complete Finite Automata, i.e., Rule 110, etc., etc.)

Anyway, excellent link, and we welcome Tree Calculus to this list!

Related: https://en.wikipedia.org/wiki/One-instruction_set_computer

peter_d_sherman··on Digital Sovereignty: What It Is, What It Could Be
Related:

Neoclouds vs. Hyperscalers: Key Differences and When to Use Each:

https://www.nutanix.com/blog/neoclouds-vs-hyperscalers

peter_d_sherman··on Homotopy Type Theory – Univalent Foundations of Mathematics (2013)
I asked Gemini AI what the current state of research was for attempts at unifying all of the operators in Mathematics into a single unified operator...

I received several answers including Category Theory (everything reduces down to a single operation called a 'composition'), Lambda Calculus (everything reduces down to function application), Formal Rewriting Systems / Symbol Substitution / Post Canonical System / Markov Algorithm (everything reduces to a single operation: string rewriting, matching a pattern of symbols and replacing it with another. Turing Machines, for example, exist within this space...)

And I also received the following:

>"Homotopy Type Theory (Paths as Transformations)

In contemporary foundational mathematics, Homotopy Type Theory (HoTT)—championed by the late Vladimir Voevodsky and a global community of mathematicians—redefines equality itself as a transformation. The Core Idea: In HoTT, statements of equality (a = b) are not static truth values; they are paths (or continuous transformations) living in a higher-dimensional space.

The Reduction: Logical proofs, algebraic manipulations, and geometric deformations are all unified under the concept of "path induction." Proving that two mathematical structures are equivalent is equivalent to finding a continuous path of transformation between them."

How interesting! Homotopy Type Theory is definitely novel in this space of ideas...

Related:

https://homotopytypetheory.org/book/

https://homotopytypetheory.org/

peter_d_sherman··on How AI Is Changing Audio Restoration in 2026
>"Understanding Spectral Recovery

When audio is heavily compressed (like early low-bitrate MP3s) or recorded on low-quality equipment (like a phone call), the high frequencies are the first casualty. Spectral recovery is the process of analyzing the surviving audio and mathematically predicting what the missing frequencies should have been.

How Spectral Analysis Works

Modern AI models utilize deep neural networks trained on millions of hours of high-fidelity audio. When fed a degraded signal, the AI performs a Fast Fourier Transform (FFT) to break the sound into its spectral components. It then compares this incomplete spectrum against its training data to identify the instrument or voice type."

This is interesting... to date, we have Neural Networks that transform text to text, text to images, images to text, text to video, etc., etc. -- but the idea of a Fast Fourier Transform (FFT) on a sound (or a stream of them) as an input and a corresponding sound (aka, "bitstream representing multiple vibrations / modes / phases of sound at a specific encoding/decoding frequency/bandwidth") for an output, is rather a radical (and brilliant!) idea, indeed!

See, that could also apply to control systems at much higher frequencies, as well...

>"Technical Depth: Harmonic Reconstruction

The AI acts as a phase vocoder on steroids. It doesn't just paste generic high-frequency noise over the track; it ensures that the synthesized harmonics are perfectly phase-aligned with the fundamental tones. This prevents the smearing and phase cancellation that plagued earlier attempts at audio enhancement."

Observation: The same technology could be used for phase cancellation if desired (i.e., noise-cancelling headphones) or phase cancellation in other electronic systems (i.e., to match a changing impedance between two related circuits that work best together if their impedance is matched, etc.)

peter_d_sherman··on Blue-X – Exploring wavelength reduction (2–7 nm range) beyond EUV
>"The presentation outlined Blue-X as an industry-wide initiative exploring wavelength reduction (2–7 nm range) as a complementary path to extending Moore’s Law beyond High-NA EUV.

The talk began by positioning the Blue-X approach relative to proposals for increasing numerical aperture beyond High-NA EUV. By selecting a wavelength of 3.1 nm and an NA of 0.27, we demonstrated that a depth of focus of ~43 nm and k₁ ≈ 0.6 can be achieved for resolving 7 nm half-pitch metal nodes projected for the mid-2030s. Unlike Hyper-NA, which faces increasing challenges in depth of focus, mask 3D effects, and cost of ownership, Blue-X leverages wavelength scaling—historically the primary driver of lithographic advancement.

The Blue-X TWG consortium now includes more than 75 member organizations and over 220 assignees representing chip makers, OEMs, national laboratories, universities, and consultants. Eleven sub-TWGs, led by recognized technology leaders, are actively evaluating optics, plasma and FEL photon sources, resist and patterning, masks, optical constants, and scanner design. The initial focus on resist exposure at 6.7 nm has shifted to 3.1 nm, with ongoing resist evaluations at Berkeley Lab and planned open-frame and interference lithography exposures at PSI beginning mid-2026.

Key technical highlights included:

o Multilayer (ML) optics in the water window region, with Sc/Cr at 3.127 nm selected as the current working baseline.

o Strategies to improve ML reflectivity from ~40% today toward 55–60% through interface control and roughness reduction.

o Plasma source modeling (Ga and Sc) and FEL development efforts, including tunable 2–7 nm capability with narrow bandwidth and reduced out-of-band radiation.

o 6.7 nm resist dose-to-clear values primarily in the 50–150 mJ/cm² range.

o Flare control and MSFR requirements (~20 pm range) for 3.1 nm optics.

o Four proposed paths to reduce stochastics at shorter wavelengths:

o Three-beam lithography (IBM)

o Larger masks (12-inch, 8×) (IBM)

o Dose partitioning

o Image contrast enhancement inspired by soft X-ray microscopy techniques

[...]

The central message is clear:

moving from 13.5 nm to 3.1 nm is not the introduction of a fundamentally new technology stack, but rather a challenging and systematic upgrade building upon the physics, infrastructure, and lessons learned from 193 nm to EUVL.

Blue-X represents a coordinated, pre-competitive industry effort to explore this next wavelength node responsibly and collaboratively."

peter_d_sherman··on RISC-V Emulator and Linux System from Scratch
>"Source Code

/lib contains the entire rv32ima instruction set emulator code as well as a minimal set of emulated devices"

The author of this GitHub repository is not lying when he says "minimal" -- basically it's an emulated 8250 UART, and that's it!

(Unless of course you count RAM (ram.hpp) and MMU (mmu.hpp) as "devices", in which case the emulated device count is three, as opposed to one...)

Now, that's not a bad thing... in fact, that's a very very good thing, an excellent thing in fact!

This whole project is brilliant!

But, let's truly understand its brilliance.

By writing this project the way it has been written, the author has stripped away somewhere between 1.5 to 2 million lines of QEMU source code (estimates put the lines of code in QEMU somewhere between these numbers), and replaced it with something far, far simpler to understand -- a decrease in the orders of magnitude of lines of code -- with a corresponding orders of magnitude increase of any given programmer's ability to understand the code.

Phrased another way:

"The learning curve for a programmer to understand a given piece of Open Source Software in a fixed time interval is approximately inversely proportional to its lines of code (LOC)."

The above repository, by reducing the lines of code necessary for an emulator to run Linux to its absolute, barest, vanilla minimum, correspondingly allows students (and future students!) of emulators to get a foothold on understanding what's going on under the hood, while having to wrestle with the least amount of lines of code (or close to it!) necessary to gain this understanding.

Well done! (And, a brilliant idea to only emulate a 8250 UART, by the way!)

peter_d_sherman··on ESP32 Bit Pirate Hardware Hacking Kit with Web Tools That Speaks Every Protocol
Looks like a tremendously useful tool to do such things as BIOS reflashing (i.e., Coreboot, Libreboot, Canoeboot) on one's own hardware.

In theory, any Single Board Computer (Raspberry Pi, Orange Pi, FPGA-based-board, etc.) or microcontroller-based circuit board with GPIO pins that can handle the speed/frequency and the voltage of what's being communicated with, could work (if the appropriate software/protocols are implemented), but ESP32 microcontroller boards, being as cheap and ubiquitous as they are, are great candidates for this task.

Anyway, ESP32 Bit Pirate looks very promising in this arena!

peter_d_sherman··on DeepSeek v4.1 Flash
>"Smaller KV cache. Bigger savings.

Compared with the previous generation, V4.1-Flash’s KV cache needs just:

o 1/4 the HBM

o 1/8 the SSD storage

Cache-hit charges often account for a large share of agent costs. Compressing the cache cuts those costs significantly."

It makes one wonder as to just how far an LLM's KV cache could theoretically be shrunk before losing significant functionality...

peter_d_sherman··on Looped Transformers as Programmable Computers (2023)
>"We present a framework for using transformer networks as universal computers by programming them with specific weights and placing them in a loop. Our input sequence acts as a punchcard, consisting of instructions and memory for data read/writes. We demonstrate that a constant number of encoder layers can emulate basic computing blocks, including embedding edit operations, non-linear functions, function calls, program counters, and conditional branches.

Using these building blocks, we emulate a small instruction-set computer. This allows us to map iterative algorithms to programs that can be executed by a looped, 13-layer transformer."

Amazing!

← PreviousPage 4 of 34Next →