0x000xca0xfe

Make it a written rule please, and legally binding.

https://news.ycombinator.com/item?id=50002301#50006029

Local models are obviously not good enough (yet), you don't need "research" to know this.

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?

   - 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

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.

But the approach should work with all of those ~2000s simple 2D/light 3D Windows games, like Anno, C&C etc. that have less than 1GB of assets and no serious multithreading. Newer ones probably won't fit into a browser tab anymore or would take too long to load.

The biggest problem for the smartphone browser version is extensive use of left+right mouse input of that era which is naturally not a good fit for touchscreens.

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...

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

    #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;
    }

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 did not work properly on Wine nor Windows 10, that was the entire reason for trying it out.

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 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.

Is a series of matrix multiplications on a token vector not a mechanical transformation?

Where is the point where you start to anthropomorphize it?

Allowing tools to insert themselves into the git history only makes sense if you are purely vibecoding with a single model and don't even bother to check and clean it up anymore. Is this truly the default state of software development already? How the times have changed.

I use many tools to develop software and if my IDE would silently start adding "This commit was created with IntelliJ IDEA Ultimate" I'd find it intrusive and obnoxious, too.

If you didn't even spend a minute writing a couple sentences about your own project, how much effort did you put into actually building and testing it? Or are you just letting others do the hard parts: Review and verification that your vibe-slop actually works as claimed, and then feed their feedback back into an LLM?

What you probably want is more memory bandwidth by default in affordable consumer PCs and I absolutely agree, it's ridiculous how we are stuck on dual channel memory controllers in consumer land despite core counts having exploded.

Port 22 is getting perma-DDOSed on public IPv4 addresses so use it at your own peril but at least for now most bots don't bother port scanning everyone.

But no, that's not what governments are doing. They want control and surveillance.

In fact it used to be a common occurence during the heavy industrial pollution in the 20th century. So much that after the pollution stopped, farmers had to start applying sulphur to their fields as nutrients for some crops (I learned about this after unsuccessfully trying to grow tomatoes in alkaline soil).

Since Microsoft has become a proponent for open source and models, a truly impressive demo would now be to use Kimi K3 to reverse the real XP binaries and turn them back into readable and copyright-free source code.

Although there are many sunny countries where solar + one or two days of battery storage are probably enough for the full year.