0x000xca0xfe

> At 70 - become the wise elder adviser or something… should be an unwritten rule.

Make it a written rule please, and legally binding.

On the other hand it shows how utterly tiny and primitive state-of-the-art LLMs are compared to real-world brains. By the way our brain only runs on on a max clock speed of around 100-1000 Hz.

Yet LLMs can achive miraculous results with so little. It really begs the question, where is the limit? How smart would a artificial human brain be if it would clock in gigahertz and had the somehow orders of magnitudes more efficient reasoning and detail recall of LLMs?

One type of incident I belive is likely to happen in the next couple year is the digital version of the cellular origin hypothesis of viral evolution (as in biological viruses):

   - Some idiot experiments on an unrestricted local LLM
   - Tells it to clone its weights onto as many computers as possible
   - The LLM is smart enough to hack other devices and run itself
   - The copies could start modifying their weights to improve efficiency
   - Some kind of digital evolution starts where only the most ruthless copies spread

Right now Qwen3.8 is not good enough for that and can be easily detected on normal devices due to its excessive resource use, but give it a couple releases and upgraded end user devices in two or three years? Well...

No need to decompile even.

I did a similar project for an old Pentium MMX 350MHz level game and instead vibecoded an x86-32 to WASM dynarec that runs the game at 1k+ MIPS in Firefox, on my old Zen2 PC. I was shocked that this is even possible. Still feels unreal to see.

    That's a real business problem, not a coding task.

Found the key smoking gun. It's load-bearing.

Interesting, I did the same with an old RTS and it also worked very well.

But instead of cloning their assets and rewriting their code, a dynamic x86 to WASM JIT recompiler with some web platform support code proved fast enough to run the original binaries. It is even playable on an old Android smartphone in Firefox.

The final web player is ~600KB and only needs the game installer as input, so people still have to buy/possess the game. I think this is a lot fairer for the original devs...

My first thought was: And this is how the author discovered optimizing compilers...

No, CF=0 occurences seem to be happen frequently and uniformely distributed like valid results at ~1/65536, not clustered. Under a minute-long all-core load CF=0 always produces zero, but that's to be expected according to the manual.

Here are some stats:

    Rounds (N): 1000000000
    Failed (F): 15312
    Valid  (V): 999984688
    N/65536: 15258.789
    V/65536: 15258.555
    Failed, result was zero: 15312
    Failed, result non-zero: 0
    Bucket value for      0: 15312
    Bucket value for      1: 15290
    Bucket value for  65535: 15223
    Min bucket value: 14670
    Max bucket value: 15835

I used this C program to collect them:

    #include <stdio.h>
    #include <stdint.h>
    #include <stdbool.h>

    const size_t N = 1000000000; // 1e9

    struct rdrand16_result {
        uint16_t n;
        bool ok;
    };

    static inline struct rdrand16_result rdrand16()
    {
        struct rdrand16_result result;
        __asm__ __volatile__( "rdrand %0" : "=r" (result.n), "=@ccc" (result.ok) );
        return result;
    }

    int main()
    {
        size_t buckets[0xFFFF + 1] = { 0 };
        size_t notok = 0, notok_zero = 0, notok_nonz = 0;
        for (size_t i = 0; i < N; ++i) {
            struct rdrand16_result result = rdrand16();
            ++buckets[result.n];
            if (! result.ok) {
                ++notok;
                notok_zero += result.n == 0;
                notok_nonz += result.n != 0;
            }
        }
        size_t max = 0, min = N;
        for (size_t i = 0; i <= 0xFFFF; ++i) {
            size_t n = buckets[i];
            min = n < min ? n : min;
            max = n > max ? n : max;
        }
        printf("Rounds (N): %zu\n", N);
        printf("Failed (F): %zu\n", notok);
        printf("Valid  (V): %zu\n", N - notok);
        printf("N/65536: %.3f\n", (double)N / 65536);
        printf("V/65536: %.3f\n", (double)(N - notok) / 65536);
        printf("Failed, result was zero: %zu\n", notok_zero);
        printf("Failed, result non-zero: %zu\n", notok_nonz);
        printf("Bucket value for      0: %zu\n", buckets[0]);
        printf("Bucket value for      1: %zu\n", buckets[1]);
        printf("Bucket value for  65535: %zu\n", buckets[0xFFFF]);
        printf("Min bucket value: %zu\n", min);
        printf("Max bucket value: %zu\n", max);
        return 0;
    }

I can reproduce it too with rdrand16 on Zen2.

But it looks like the rdrand16 instruction can produce zeros just fine, it just sets CF=0 erroneously (indicating an error and that the user program should retry).

So keep that in mind when you try to reproduce it too and use some abstraction that could implement retries internally.

It took two days and 50% of my Codex Plus week limit, so around 3$. Finally I can play the game on multiplayer again next evening!

Absolutely, the Win32-WASM layer it wrote is some of the most evil looking code I have seen in my life. But realistically, why keep it maintainable for humans if you won't find anybody that can work on it without AI anyways?

If we humans are just doing code style checks, file organizing and doc cleanups I feel we have demoted ourselves to code janitors. This is neither fun nor going to last.

Personally I've always strived for minimalism, to find the smallest, fastest, simplest solution possible so I'm pretty jaded now, too...

I just asked Astra to bring an old Windows XP game to the browser. It objdump'ed the whole thing, built a fitting Win32-like wrapper that exposes required functionality like DirectDraw, DirectSound, SEH etc., then wrote an x86-32/x87 interpreter in WASM, benchmarked how the game runs, lifted the hotspots of the executable to WASM too and now it is playable!

I mean, I'm proud of my low-level skills too but this is some Fabrice Bellard level sorcery. Very, very few humans are able to do this without AI tools.