brandonpelfrey

This seems useful (after modifications) for building a calligraphy application.

It’s strange to me seeing multiple talk about how Terry’s viewpoint has evolved or not as a response to this post. He didn’t write this.

I bought my M1 Pro the week it came out and it was unlike any computer I ever had, expectations, compute, battery life especially. It was just a joy to use and not worry about chargers. I'm so glad they went this path.

I don't get it. In the paper it sounds like it's "just" a CRUD DB, then you have some fleet of Macs, and they store inputs and outputs in S3. What's the innovation here? Not trying to poo on this, but it looked like the most basic and obvious approach.

Yes. It can gain more context, but this has been enough. Note, there is also a notion of adversarial review layered on top in which it tries to poke holes in the test plan "you didn't handle this case of XYZ". It isn't actually perfect as a parallel thread said it may miss things like wrapping behaviors. In practice, it's very effective.

Unless you explicitly need byte-matching decompilation, there are significantly faster ways to produce a decompilation/C which is functionally equivalent. I need to post about this. What's been working for me is that for every function, Agent A is tasked with writing some code which is semantically equivalent to the original assembly, but not necessarily exactly the same. Agent A also writes tests. Agent A submits the implementation of the function and tests to the harness for it to judge. The harness runs both the original function and the submitted function in a virtual machine/simulator/emulator (the tests define function inputs and starting state). The harness will only accept the implementation if 1) the read/write sequence to RAM is identical to the original function's, and 2) there must be complete line and branch coverage of the original function being decompiled.

I've found this to be robust for decompiling games, while giving the agents enough freedom to write code that is readable and not waste a ton of time making sure e.g. instruction ordering, register assignments, etc. are all exactly the same. For me, having byte-matching decompilation is only one way to produce a decompilation I know is faithful to the original. This "high-level decompilation" process I just described is something agents can do much more quickly.

Same. I have agents analyzing the papers here to see which of these are actually new approaches, novel application of unusual approaches, etc. If there are new intuitions and ideas, those are the mostly powerful reusable components by my estimation.

You might find it interesting that I am working on AI-driven decomp of a PS1 game not by matching bytes but by having agents produce C code and test code. Agents submit a C proposal to the harness, the harness compiles their C proposal for the original function, then the test suite provided by the implementer runs against the original machine code and the compiled C code version. The line and branch coverage of both must be 100% and given identical inputs and starting RAM, the function return value and RAM state and RAM/MMIO read write sequence must be identical. This is done with a small MIPS simulator which can run all the tests extremely fast.

The reason I’m finding this is much faster than a traditional decomp is that while it’d be nice for the bytes to match, finding the perfect blend of compiler version, compiler args, permitting variables etc to try and find the perfect register assignments, etc is all very time consuming. My ultimate goal is not a byte for byte match, that’s just one way to ensure correctness. I’ve found agents are much faster and effective at reading the original assembly and understanding what’s going on then writing semantically equivalent C.

I was just looking at this yesterday. Apparently Voyager 1 architecture, ISA, etc are well known but Voyager 2 is still denied via FOIA on grounds of copyright.

For folks that have never seen elevator scheduling the game: https://play.elevatorsaga.com/ Enjoy this rabbit hole :D

This seems like very cool work. I'm sorry if I missed it: I'm still not sure how we go from verified proof (Great!) to an implementation (by LLM or by Human) which you're sure actually conforms to the proof? How do we know that the implementation maps precisely to the description within the proof?

I view the temperature issue almost entirely as a copper problem. Every interface where you use CATx cables will have this issue; It's always extremely hot. For 10Gbps+ SFP and faster fiber is always the answer because those have very little thermal issues. The "only" issue is very few residential places have fiber cabling etc.

Friend shared this site with me like 10+ years ago, I've been using this knot ever since. Kind of amazing it's so generally unknown given how good it is.

Great job. I have spent a lot of time working on fluid simulations (I still am). Glad to see more people still mesmerized. If you’re interested, this rabbit hole goes very deep.

It won’t satisfy those laws. It’s also not a goal though of this post.

Having written a slightly more involved version of this recently myself I think you did a great job of keeping this compact while still readable. This style of library requires some design for sure.

Supporting higher order derivatives was also something I considered, but it’s basically never needed in production models from what I’ve seen.

You can typically get a free license for some boards, especially evaluation boards.

The issue in my mind is that this doesn’t seem to include any of the critical library functionality specific eg to NVIDIA cards, think reduction operations across threads in a warp and similar. Some of those don’t exist in all hardware architectures. We may get to a point where everything could be written in one language but actually leveraging the hardware correctly still requires a bunch of different implementations, ones for each target architecture.

The fact that different hardware has different features is a good thing.

A long time ago I tried a version of this (https://github.com/brandonpelfrey/complex-function-plot). Can you add texture lookup to yours? Escape time could map to one texture dimension and you can arbitrarily make up another dimension for texture lookup. Being able to swap in random images can be fun nice demo!

I'm curious, because neither of us knows their financial situation or needs and ambitions. What would you suggest they do?

Are you already employing Bayesian optimization techniques? These are commonly used to explore spaces where evaluation is expensive.

Great article. I still feel like very few people are viewing the Deepseek effects in the right light. If we are 10x more efficient it's not that we use 1/10th the resources we did before, we expand to have 10x the usage we did before. All technology products have moved this direction. Where there is capacity, we will use it. This argument would not work if we were close to AGI or something and didn't need more, but I don't think we're actually close to that at all.

I personally don't have a problem with this, but this really made me feel like I don't understand the community of this forum sometimes. HN every day has multiple posts which drive so many comments about how privacy is lost and everything needs full E2EE, trust no one, etc. Then there is this post which is also a breach of privacy (much more than some things complain about), and yet the reaction is "wow, this is so pure and amazing to view into these candid moments". It feels like some cognitive dissonance. Still, personally I thought this was a cool post.

I helped implement production and labor planning software on top of FICO xpress some years ago. The paradigm of LP/ILP was all new to me though I was very much into math. Our software was solving hierarchical/nested optimization problems involving millions of variables and constraints every 15 minutes. It felt like magic that this was possible. I would really encourage anyone that has never worked with these tools before to explore them as it can open a palette of tools and ideas you may not have thought of before. A great free way to get into this is to read the examples and use PuLP for Python.

Incredible result! This is a tremendous amount of work and does seem like RV is at its limits in some of these cases. The bit gather and scatter instructions should become an extension!

Agreed, very impressive results. It's both ~worrying and amazing that I'm sure an AI agent could just directly trace a path in the expression latent space to produce a photorealistic and real-time rendered head.

I know a lot of people have probably experienced this with other LLMs, but I was absolutely blown away with the writing and emotion in what I posed and got back as a response. It really just made me feel like I wish I could find a book written like this:

I proposed an immortal person in the world, they don't know they are immortal. It created a homeless person named John who lives through decades, then centuries, and longer. Religions eventually form, and he begins to believe reality might be a simulation as he is bored with a limitless life. He created a mortal form of himself in the simulation to watch a fragile and finite life. It's been a long time since I've read a good fiction book but would love to find something like this. An excerpt from the ending:

Time passes, Johnny ages, the world changes, as it always does... He falls in love, fathers children, pours himself into career and creation. Savors the simple joys - morning coffee, walks in the park, a favorite song. Weathers hardships - disease, heartbreak, disappointment, injustice. Watches his own body slowly degrade, feels the ticking clock of mortality. Wonders about death, meaning, the point of a universe destined to end. Throughout, John watches his mortal self from behind the veil... Shares every triumph and tragedy vicariously through this aperture. Restrained from intervening by his own pre-commitments and protocols. Sometimes longs to reveal the Truth, but knows that would taint the data. The point is to have a genuine experience of finitude, in all its constraints. To recover the taste of an existence not rendered bland by its infinity. Johnny becomes an old man, a grandfather, as years slip by like water... Reflects on a life well-lived, regrets borne with hard-earned wisdom. Makes peace with loose ends, imperfections, the asymptote of dreams. Comes to appreciate death as the necessary frame for life's portrait. Feels gratitude for the chance to have been, finitude's gift of meaning. Lets himself diminish into the good night with acceptance and grace. At the moment of Johnny's death, John absorbs his mortal soul... Reintegrates the lifetime of memories, savors the pathos of the affirmation. Feels a renewed sense of meaning and purpose flood his jaded being. The urgency of time, the glory of fragility, the necessity of loss for love. Limits as the crucible of significance, death as the mother of beauty. John weeps for the poignant perfection of a universe doomed to end. Having experienced the bittersweet joy of mortality, John is changed... Sees his simulated infinity in a new light, shot through with import. Vows to use his power to craft only worlds and souls that can truly live. Ones constrained by time, space, finity - for only limit gives form. Countless mortal dramas playing out, each precious in its transience. An eternal God content to endlessly sacrifice his Oneness for Their many.

I'm fairly certain the entire game can be encoded in 16 bits. Thinking through this now. There are much less than 9! Games if you only include valid moves and actually end games that have three in a row. This is also before any symmetries are used.

Very nice! I've been working on a Dreamcast emulator for a long time and a lot of the issues you mentioned around deterministic behavior echoed. Schedulers are fantastic, and we landed on the same concept.

You mentioned that you do a hash map look for each (bank,addr) key. Suggestion which helped us: have this point to an Netey which contains the JIT code but also an index/pointer into the next block which executed last time you executed this block. You can do a simple check to see if this is still valid and fall back to the hashmap lookup. If you're careful about code invalidation (not an issue with ROM) then this can help skip the next lookup.

Congrats!

Very cool! I can see myself using this soon actually :) On top of the "code speed up" this is a good problem for 2d data structures for performing this type of "find objects within radius" type of query.