Show HN: BloomPilot – AI-Powered Overlay for Bloomberg Terminal (prestigious-albatross-928.convex.app)

I wonder if IEEE-754 designers anticipated this use case during development. Great article - this kind of "outside-the-normal-use-case" requires a very careful reading of the specifications/guarantees of the language.

purplesyringa · 65d ago

IEEE-754 seems to say that NaN payloads are designed to contain "retrospective diagnostic information inherited from invalid or unavailable data and results". While NaN boxing in particular probably wasn't the intention, untouched payloads in general absolutely were.

tetris11 · 64d ago

Are there any security implications of NaN-Boxing?

If I encode data into the exponent of these NaN values, propagate them around the internet, and decode them elsewhere.... is that a security risk? Or this just falls into the category of "weird encryption"

rcxdude · 64d ago

Define security risk. Obviously this data could come from untrusted sources. Another consideration is that this data may not serialize correctly: most text serialization protocols will not distinguish different NaN values. It's possible for there to be some data confusion in your pipeline as well, if you don't control all the code that touches those bytes.

ufo · 64d ago

I'd be surprised. It's surprisingly difficult to setialize NaN values. Can't do it on JSON, for example.

yencabulator · 62d ago

Lots of formats just put the IEEE-754 bytes on the wire, as-is. For example, Protocol Buffers: https://protobuf.dev/programming-guides/encoding/

userbinator · 64d ago

It's especially useful since everything is 64 bits uniformly.

pwdisswordfishz · 64d ago

Like JavaScript. Which should immediately raise the question how it could possibly work on engines that employ it themselves. Turns out... it won't.

addoo · 65d ago

I appreciate this article a lot more because it contains an iota of benchmarking with an explanation about why this might be more performant. Especially since my first thought was 'wouldn't this require more instructions to be executed?'

The original post seems really weird to me. I would have dismissed it as someone's hobby project, but... that doesn't seem like what it's trying to be.

Tuna-Fish · 65d ago

"More instructions to execute" is not synonymous with "slower".

NaNboxing lets you use less memory on certain use cases. Because memory access is slow and caches are fixed size, this is usually a performance win, even if you have to do a few extra ops on every access.

thehappypm · 64d ago

I mean, a modern computer is operating the gigahertz range. Adding a few extra bitwise instructions might be something like a nanosecond. Which is absolutely fleeting compared to memory operations.

wging · 65d ago

It's a joke project.

dzaima · 65d ago

This doesn't work on Firefox, as it normalizes NaNs as they're extracted from ArrayBuffers. Presumably because SpiderMonkey uses NaN-boxing itself, and thus just doesn't have any way to represent actual non-canonical NaN floats.

sjrd · 65d ago

The spec mandates normalization of NaNs in ArrayBuffers. If other engines do not normalize, I believe it's a bug in those engines!

dzaima · 64d ago

Chromium & Node (i.e. V8) do seem to just not normalize:

    arr = new Float64Array([0]);
    arr[0] = new Float64Array(new BigUint64Array([-123n]).buffer)[0];
    [...new Uint8Array(arr.buffer)] // [133, 255, 255, 255, 255, 255, 255, 255]

vhcr · 64d ago

Running the following snippets:

    f = new Float64Array(1)
    dv = new DataView(f.buffer)
    dv.setBigInt64(0, -123n)
    console.log([...new Uint8Array(f.buffer)])

    f = new Float64Array(1)
    new BigUint64Array(f.buffer)[0] = -123n
    console.log([...new Uint8Array(f.buffer)])

    f = new Float64Array(1)
    f[0] = new Float64Array(new BigUint64Array([-123n]).buffer)[0]
    console.log([...new Uint8Array(f.buffer)])

    f = new Float64Array([NaN])
    console.log([...new Uint8Array(f.buffer)])

I get on Chrome:

    [255, 255, 255, 255, 255, 255, 255, 133]
    [133, 255, 255, 255, 255, 255, 255, 255]
    [133, 255, 255, 255, 255, 255, 255, 255]
    [0, 0, 0, 0, 0, 0, 248, 127]

And on Firefox:

    [ 255, 255, 255, 255, 255, 255, 255, 133 ]
    [ 133, 255, 255, 255, 255, 255, 255, 255 ]
    [ 0, 0, 0, 0, 0, 0, 248, 127 ]
    [ 0, 0, 0, 0, 0, 0, 248, 127 ]

It looks like both implementations are buggy, Since both the DataView and buffer versions should be normalized.

https://bugzilla.mozilla.org/show_bug.cgi?id=1393085

moffkalast · 65d ago

Dammit Mozilla, first no WebGPU, now this?! /s

o11c · 65d ago

Note that there are a lot of exciting new float-related functions in C23, many related to NaN handling, signed zeros, or precision in edge cases. Some have been in glibc for years; others not yet.

The API for `getpayload`/`setpayload`/`setpayloadsig` looks a little funny but it's easy enough to wrap (just consider the edge cases; in particular remember that whether 0 is valid for quiet or signaling NaNs is platform-dependent).

Finally we have a reliable `roundeven`, and the convenience of directly calling `nextup`/`nextdown` (but note that you'll still only visit one of the zeros).

The new `fmaximum` family is confusing, but I think I have it clear:

  without 'imum' (legacy): prefer non-NaN
  with 'imum': zeros distinguished (-0 < +0)
  with '_num': prefer a non-NaN, also signal if applicable
  with '_mag': compare as if fabs first

`totalorder` has been often-desired; the other new comparisons not so much.

`rootn` and `compoundn` are surprisingly tricky to implement yourself. I still have one testcase I'm not sure why I have to hand-patch, and I'm not sure which implementation choice keeps the best precision (to say nothing of correct rounding mode).

Etheryte · 65d ago

> but note that you'll still only visit one of the zeros

Out of curiosity, isn't this what you'd pretty much universally want? Or maybe I misunderstand the intent here?

o11c · 65d ago

I find `nextup/`nextdown` useful for when you want to calculate `{f(nextdown(x)), f(x), f(nextup(x))}` and see if some property holds (or to what degree it holds) for both `x` and its surrounding values. It's annoying that one such surrounding value gets skipped.

That said, quite often you need to handle signed zero specially already, and if you don't the property you're testing might sufficiently differ in the interesting way for the smallest-magnitude subnormals.

vitaut · 65d ago

I made a garlic nan: https://www.godbolt.org/z/enjv1c7Tf

dgroshev · 65d ago

I love it, how did I not think about this!

scorchingjello · 65d ago

Since the first time I had Indian food sometime in 1987 I have always called naan “not a number bread” and no one has ever laughed. I feel like i may have found my people.

dspillett · 65d ago

This may appeal: https://doubleyoudoubledoubleewe.www.dash.deeohhtee.dash-das...

clhodapp · 65d ago

I guess I just don't get it because the before & after cases don't seem to be showing remotely comparable use cases.

In the "before" use-cases, the programmer has accidentally written a bug and gets back a single NaN from a logical operation they performed as a result.

In the "after" cases, the programmer already has some data and explicitly decides to convert it to a NaN encoding. But instead of actually getting back a NaN that is secretly carrying their data, they actually get a whole array of NaN's, which duck type differently, and thus are likely to disappear into another NaN or an undefined if they are propagated through an API.

Like.. I get that the whole thing is supposed to be humorously absurd but... It just doesn't land unless there's something technical I'm missing to connect up the pieces.

brap · 65d ago

It sounds like you might be interested in the Enterprise Edition

amelius · 65d ago

I'm curious why we have not-a-number, but not not-a-string, not-a-boolean, not-an-enum, and not-a-mycustomtype.

dzaima · 65d ago

Because NaNs come from a standardized hardware-supported type, whereas the rest of those are largely language-specific (and you could consider null/nil as a "not-a-*" type for those in applicable languages; and there are languages which disallow NaN floats too, which completes all combinations).

Itanium had a bit for "not a thing" for integers (and perhaps some older hardware from around the time floats started being a thing had similar things), so the idea of hardware support for not-a-* isn't exclusive to floats, but evidently this hasn't caught on; generally it's messy because it needs a bit pattern to yoink, but many types already use all possible ones (whereas floats already needed to chop out some for infinities).

Sharlin · 65d ago

Because IEEE 754 creators wanted to signal non-trapping error conditions for mathematically undefined operations, and they had a plenty of bit patterns to spare. Apparently back in the 70s and 80s in many cases it was preferable for a computation to go through and produce NaNs rather than trapping instantly when executing an undefined operation. I'm not quite sure what the reasoning was exactly.

wbl · 65d ago

In early FP machines the floating point processor could not take a trap at a faulting instruction precisely: it could only go bad things. Furthermore for programmers and hardware it can be very expensive. Rather than go through a loop and filter NaN out of results it becomes trap every time and resume and is a pain.

IshKebab · 65d ago

It avoids traps which are really inconvenient.

Sharlin · 65d ago

You can encode not-a-bool, not-a-(utf-8)-string and not-an-enum using one of the invalid bit patterns – that's exactly what the Rust compiler can do with its "niche optimization": https://www.0xatticus.com/posts/understanding_rust_niche/

IncreasePosts · 65d ago

Some common numeric operations can result in non-numbers(eg division by zero - Nan or infinity).

Are there any common string operations with similar behavior?

masfuerte · 65d ago

Out of range substring? Some languages throw an error, others return an empty string. You could return a propagating NaS instead. I don't know what you'd use it for.

cluckindan · 65d ago

Charset translation.

Unicode’s � is basically a symbol for not-a-char.

mathgradthrow · 65d ago

Nana basically means that floating point arithmetic is predicting that your mathematical expression is an "indeterminate form", as in the thing you learn in calculus.

sgerenser · 65d ago

Not-a-boolean would be something like the much maligned tri-state bool pattern: https://thedailywtf.com/articles/What_Is_Truth_0x3f_

usefulcat · 65d ago

C++ has std::optional for exactly that purpose.

ok_computer · 65d ago

Because representing infinity is not possible outside of symbolic logic and isn’t encodable in floats. I think it is a simple numerical reason and not a deeper computer reason.

Sharlin · 65d ago

Well, infinity is totally representable with IEEE 754 floats. For example 1.0/0.0 == +inf, -1.0/0.0 == -inf, but 0.0/0.0 == NaN.

amelius · 65d ago

A smart compiler should be able to figure out a better value for 0/0, depending on context.

For example:

    for i in range(0, 10):
        print(i/0.0)

In this case it should probably print +inf when i == 0.

But:

    for i in range(-10, 10):
        print(i/0.0)

Now it is not clear, but at least we know it's an infinity so perhaps we need a special value +-inf.

And:

    for i in range(-10, 10):
        print(i/i)

In this case, the value for 0/0 can be 1.

Sharlin · 65d ago

Well, it could, but that would be against the spec. The hardware implements IEEE 754, most languages guarantee IEEE 754, and transforming code so that 0.0/0.0 doesn't result in NaN would be invalid.

ok_computer · 65d ago

I'm incorrect. there's a spec discussed here

https://www.gnu.org/software/libc/manual/html_node/Infinity-...

stevage · 64d ago

You missed not-a-NaN.

indigoabstract · 64d ago

Also GNU, since it's not-a-unix.

dunham · 65d ago

I learned about this when trying to decode data from Firefox IndexedDB. (I was extracting Tana data.) Their structured clone data format uses nan-boxing for serialization.

yapyap · 64d ago

‘Stuff your nan’ is this intentional? From a UK perspective this sounds wild

phpnode · 64d ago

Stuffed Na(a)N as in naan bread https://commons.m.wikimedia.org/wiki/File:Stuffed_Naan.JPG

haxiomic · 65d ago

That's curious! Does anyone know why the spec was designed to allow so many possible NaN bit patterns? Seems like just one would do!

dzaima · 65d ago

As long as you want all bit patterns to be Some float, there's not really one bit pattern you can chop out of somewhere (or, three, rather - both infinities, and NaN).

Taking, say, the 3 smallest subnormal numbers, or the three largest numbers, or whatever, would be extremely bad for allowing optimizations/algorithms/correctness checkers to reason about operations in the abstract.

brewmarche · 65d ago

You can put diagnostic information about the cause of the NaN in the bits. IEEE754 doesn’t mandate any format though, leaving it up to the implementation. You can check section 6 of IEEE754:2019 (which also talks about the possibility to use it to extend the standard to wider ranges, more infinities or other stuff)

AaronAPU · 65d ago

Reminds me of using the highest bit(s) of 64-bit ints to stuff auxiliary data into lockfree algorithms. So long as you’re aware of your OS environment you can enable some efficiencies you couldn’t otherwise.

eru · 65d ago

That's why OCaml has 63 bit integers by default: the language itself uses the last bit to help with GC.

carterschonwald · 65d ago

The nan bits were intended to help provide more informative float error diagnostics at the language implementation level for non crashing code. I wonder if I’ll ever get to exploring it myself.

roywiggins · 65d ago

Four NaNs? Four? That's insane.

https://m.youtube.com/watch?v=feJlRDLX0iQ

gitroom · 64d ago

well i totally relate to calling naan not-a-number bread, it's been stuck in my head ever since i learned about NaNs tbh

johnklos · 65d ago

It's a shame this won't work on VAX.

Show HN: TokenDagger – A tokenizer faster than OpenAI's Tiktoken (github.com)

Show HN: New Ensō – first public beta (untested.sonnet.io)

Show HN: We're two coffee nerds who built an AI app to track beans and recipes (beanbook.app)

Show HN: Open-Source International Space Station Tracker ESP32/Arduino for $20 (github.com)

Show HN: A continuation of IRS Direct File that can be self-hosted (github.com)

Show HN: Timezone converter that tells you if your meeting time sucks (timezig.com)

Show HN: C.O.R.E – Opensource, user owned, shareable memory for Claude, Cursor (github.com)

Show HN: Private real-time dictation app for Mac (github.com)

Show HN: I built a daily sunlight tracker (lumehealth.io)

Show HN: Audiopipe – Pipeline for audio diarization, denoising and transcription (github.com)

Show HN: Attach Gateway – one-command OIDC/DID auth for local LLMs (github.com)

Show HN: Octelium – FOSS Alternative to Teleport, Cloudflare, Tailscale, Ngrok (github.com)

Show HN: ArcFont – Font Embedding Model (github.com)

Show HN: QuizKnit, an open source quiz creator (quizknit.com)

Show HN: MailMap – Turn emails into interactive stories on Google Maps (mailmap.site)

Show HN: I'm an airline pilot – I built interactive graphs/globes of my flights (jameshard.ing)

Show HN: Summle – A little maths Game (summle.net)

Show HN: Sharpe Ratio Calculation Tool (fundratios.com)

Show HN: Semantic-dictionary – A Python dictionary with semantic lookup (github.com)

Show HN: DotnetEbpf - Write Linux eBPF kernel applications in C# (github.com)

Show HN: Ravana, Multi AI Assistant Browser Desktop App (github.com)

Show HN: AGL a toy language that compiles to Go (github.com)

Show HN: My Cross-Platform MySQL Parser (abbychau.github.io)

Show HN: Vet – A tool for safely running remote shell scripts (getvet.sh)

Show HN: AI image alt text generation tool – Turn images into text with AI (imagerr.ai)

Show HN: A tool to benchmark LLM APIs (OpenAI, Claude, local/self-hosted) (llmapitest.com)

Show HN: Sink – Sync any directory with any device on your local network (github.com)

Show HN: A different kind of AI Video generation

Show HN: Flutter Course 3.0: A Browser IDE (hungrimind.com)

Show HN: Magnitude – Open-source AI browser automation framework (github.com)

Show HN: Do you know RGB? (maxwellito.github.io)

Show HN: Zenta – Mindfulness for Terminal Users (github.com)

Show HN: I built an AI dataset generator (github.com)

Show HN: SmartStepper – Multi-Step Form Library with Config-Based Flow (github.com)

Show HN: SVG Lined Tile Generator (adpreese.github.io)

Show HN: Layerfig Type-safe layered config for JavaScript/TS with any validator (layerfig.dev)

Show HN: Tablr – Supabase with AI Features (tablr.dev)

Show HN: Oasis – An open-source, 3D-printed smart terrarium (github.com)

Show HN: BloomPilot – AI-Powered Overlay for Bloomberg Terminal (prestigious-albatross-928.convex.app)

Show HN: Ciara – Securely deploy any application on any server (ciara-deploy.dev)

Show HN: Scream to Unlock – Blocks social media until you scream “I'm a loser”

Show HN: PILF, The ultimate solution to catastrophic oblivion on AI models (github.com)

Show HN: Anti-Cluely – Detect virtual devices and cheating tools on exam systems (anti-cluely.com)

Show HN: Ketcher Docker – Self-Hosting Advanced Chemical Structure Editor (github.com)

Show HN: EliteSaaS – Self-Contained SaaS Starter (Auth, Billing, Email, Launch) (elitesaas.dev)

Show HN: PRSS Site Creator – Create Blogs and Websites from Your Desktop (prss.co)

Show HN: Elelem, a tool-calling CLI for Ollama and DeepSeek in C (codeberg.org)

Show HN: Anagnorisis. A Vision for Better Information Management (medium.com)

Show HN: Visualizing method dependencies over classes in C# and TypeScript (github.com)

Show HN: Clai - Vendor agnostic Claude Code/Gemini CLI written in Go (github.com)

Stuffed-Na(a)N: stuff your NaNs

Comments (58)