ollin

I think it's from lyra's neuron-explorer project https://x.com/_lyraaaa_/status/2113833330429083662 (see also https://neuronary.org/about, https://github.com/lyramakesmusic/neuron-explorer)

I was confused too, but it looks like https://github.com/openai/math/blob/main/lean/ComparatorChal... (with the sorry at the end) is just the problem statement; the actual proof is a big pile of lean in the Algorithms folder, with the final theorem stated here https://github.com/openai/math/blob/7ef5c0cc5ca4b0e072b7a050...

Right! The 256 introduced hardware T&L, which was a great advance in capability (but harder to explain than "it's the first GPU"). From the same chapter [1]:

   It was incontrovertibly true that the GeForce 256 represented a significant advancement in traditional graphics capabilities, which by this point was typical and expected of every new chip generation Nvidia produced. It featured four graphics pipelines, allowing it to process four pixels at the same time. It also integrated a hardware transform and lighting (T&L) engine, which meant it could take on the calculation tasks essential to the moving, rotation, and scaling of 3-D objects.

    Those tasks were usually handled by the CPU; the GeForce 256 thus took even more computational burden off of the CPU and made the entire computer run faster.
    
    "By putting dedicated hardware to do that, you could suddenly process a lot more geometry and make much more interesting pictures," said former chief scientist David Kirk.
    
    The management team at Nvidia thought that this was far too technical to pitch to customers. The typical in-house naming formula of acronym and number wouldn't work. Nvidia needed something bigger to market its new product.
    
    "We had to find a way to position this product as a much better graphics processor for 3-D graphics than anything out there," said Dan Vivoli. "The chip is big. It has texture and lighting. We've got to charge a lot for it. We need to come up with a way to make sure how great this thing is." He challenged his product-marketing team to come up with something brilliant.

[1] The NVIDIA Way / https://www.taekim.com again

Per The NVIDIA Way [1], the GeForce 256 was branded as "the first GPU" for marketing reasons alone; the actual first GPU was the subsequent GeForce 3 (which introduced programmable shaders):

    [Sanford] Russell grabbed Michael Hara for a thirty-minute brainstorm session to figure out how to market the GeForce 256 more effectively, and both executives remember coming out of the room with the notion to call the new chip the first entry in an entirely new product category altogether: a graphics processing unit, or GPU, which would be to graphics rendering what the computer's main central processing unit (CPU) was for all other computational tasks.

    Even so, the GPU moniker, when applied first to the GeForce 256, was controversial among Nvidia engineers, who pointed out that a chip could not truly be called a GPU unless it had several features that the GeForce 256 did not. The chip lacked a "state machine," a technical term meaning a dedicated processor that transitions from various states to execute and fetch instructions, in the same manner that a CPU does for programming commands. It was not programmable, meaning that graphics styles and features could not easily be customized by third-party developers. Instead, developers would have to rely on a fixed set of Nvidia-defined hardware functions. Moreover, the GeForce 256 did not have its own programming language.

    But the marketing team argued that such features were already planned for the next generation of graphics chips. And even without them, the GeForce 256 delivered a step change in performance that would be obvious to every gamer and computer enthusiast in the world. While not literally a GPU, the GeForce 256 could still be a category-defining product. The chips that would follow-the "true" GPUs that would be fully programmable by outside developers-were coming soon enough.

    So Nvidia's marketing team pushed forward with the GPU name over the dissent of Nvidia's engineers. "We don't need anyone's approval," Vivoli told them. He didn't think anyone outside of the industry would really care about the technical definition. Besides, "we knew the next one was going to be programmable. We decided to take a leap, make a stretch that this is a GPU."

    In February 2001, Nvidia released the GeForce 3, whose programmable shader technology and support for third-party development of its core graphics functions made it the first true GPU.

[1] https://www.taekim.com

OpenAI added a camera behind the TV after they found the bug (per the AP story [1]):

    The company subsequently added a camera to the room that last week captured Alfozan entering and checking behind the television where the recording device was installed, according to the FBI.

https://apnews.com/article/ai-fbi-justice-department-7f512b2...

This is a technical companion post to https://xbow.com/blog/xbow-built-a-chrome-full-chain-exploit

    document.querySelectorAll("canvas").forEach(c=>c.style.opacity = 0)

in the console eliminated the cursor effect for me

This news article [1] had a quote supposedly from the chat session:

> The arrest report states that on Sept. 26 at approximately 5:10 a.m., Heller reportedly wrote, "I'm going to shoot up the sheriff's right the [expletive] now." The following day, at approximately 1:07 a.m., she was accused of posting, "This is 100% last chance I'm done. I got a new [expletive] gun today. [Expletive] you."

[1] https://www.gulfcoastnewsnow.com/article/florida-woman-arres...

Not just bad headlines; OpenAI is actively being sued [1] for this:

    OpenAI’s stated rationale was a concern for the shooter’s privacy, but its own interests
    better explain its silence. Upon information and belief, OpenAI was seeking to avoid implementation of a
    hard line rule to refer planning of real-world violence to authorities, perhaps due to how frequently its
    product is implicated in threats to human life. Requiring such disclosures would be incompatible with the
    company’s public position that ChatGPT is safe. It could also threaten the valuation underlying OpenAI’s
    anticipated initial public offering. Rather than expose those risks, OpenAI accepted the consequences of
    its silence. A mass murder in the only secondary school in Tumbler Ridge followed.

    Accordingly, the Crown, led by Attorney General Sharma, and SD59 jointly bring this
    action to hold OpenAI and Sam Altman accountable for designing a dangerous product, distributing it to
    every home with internet access, ignoring the warnings of their own safety team,
    refusing to notify authorities when they knew the shooter was planning gun violence, inviting the shooter back onto the
    platform after deactivating the shooter’s account, and choosing corporate self-interest over the lives of
    children. They seek compensation for the not just foreseeable but known harm OpenAI inflicted, the
    damages that they incurred and are incurring, and injunctive relief to ensure that this tragedy does not
    happen again.

[1] https://cdn.arstechnica.net/wp-content/uploads/2026/09/Briti...

This paper shows a nice integration of older winner-take-all ideas for learning K-modal generative models (see e.g. https://arxiv.org/abs/1612.00197, https://arxiv.org/abs/2211.14286) into modern diffusion/flow pipelines. As-implemented, I think it has some downsides:

1. K-1 extra forward passes during training

2. Inaccurate sampling behavior (will sample all K modes with equal likelihood, rather than sampling them proportionally)

However, I think both of these downsides can be mitigated by adjusting the implementation a bit more (you can have the model predict K modes jointly in one forward pass, along with probabilities of each being the min-loss mode, which you can then use for properly-weighted mode sampling at inference).

That said, I'm not entirely sure if this strategy is as generally applicable as the authors are hoping. In particular:

1. For highly-conditional image generation (like modern commercial diffusion pipelines, which use a big LLM preprocessor), most of the low-frequency color/layout decisions are already made for you by the conditioning signal. The diffusion process mostly needs to generate high-frequency details, for which there are a huge number of equally-valid modes.

2. For LLMs themselves, the sequence-generation process is already factored into a discrete classification problem, and there's no mode smearing issue to fix.

The ExploitGym paper evaluated several frontier models on the bench and reported that "Different models find different exploits" [1], so it seems most plausible that the "test solutions directly from Hugging Face’s production database" [2] which GPT-internal found were authored by Mythos (or some other LLM with complementary strengths), and placed in some internal HF repository when creating the ExploitGym paper/leaderboard.

[1] https://www.cybergym.io/exploitgym/#:~:text=Different%20mode...

[2] https://openai.com/index/hugging-face-model-evaluation-secur...

If the HuggingFace repo the agent broke into contains reference solution scripts for ExploitGym (i.e. for exploiting the vulnerabilities in the intended way), the agent can then run that reference code inside its original sandbox to retrieve the dynamically-generated flags.

This article seems fairly uninformative since, as others have pointed out, there's no visualization or comparison of the full emoji set and no link to see it. They just show a few example images and have some (AI-enhanced?) prose that doesn't actually say very much.

This article https://9to5google.com/2026/05/12/android-17-emoji-redesign/ has a larger (2d image) comparison grid with several dozen examples and an A/B slider vs the old versions. Overall the new design looks like a fairly tasteful compromise between Google's previous flat-shaded vector emoji and the hybrid 2d+3d Apple emoji, with the benefits (easier to rerender with higher-resolution, animations, tweaked lighting, etc.) that you'd get from a fully-3D pipeline. So I like the new set of emoji, just not this particular blog.google.com article.

Yeah, that part should not be read literally; `x.cos().cos()` and `x1 = x.cos(); x2 = x1.cos()` both launch the same number of kernels (two in unfused/eager mode, one in fused/torch.compile, see this test notebook [1]). I think the author chained the two cos calls to symbolize the idea of combining them (without exposing the intermediate result), but chaining the two cos calls doesn't literally trigger operator fusion.

[1] https://colab.research.google.com/drive/13a4Y-ko6QLMPAhBz64c...

This post is a classic! Also recommended: Horace also gave a related talk (covering the high-level picture of modern ML Systems) at Jane Street in Dec 2024 https://www.youtube.com/watch?v=139UPjoq7Kw

Feet of Clay is one of my favorites in the series! It's surprising how literally the Discworld version of Golems corresponds to modern LLMs (and perhaps upcoming LLM-backed humanoids?).

The Golems are brought to life by a slip of words in their heads called chem, which is almost 1:1 to an LLM system prompt (or perhaps the Claude Soul Document):

    I AM A GOLEM. I WAS MADE OF CLAY. MY LIFE IS THE WORDS. BY MEANS OF WORDS OF PURPOSE IN MY HEAD I ACQUIRE LIFE. MY LIFE IS TO WORK. I OBEY ALL COMMANDS. I TAKE NO REST.

The Golems are perfectly intelligent and self-aware, but since they don't exhibit independent goals beyond their prompt, they get treated as appliances rather than as sentient creatures.

    “What words of purpose?”
    RELEVANT TEXT THAT ARE THE FOCUS OF BELIEF. GOLEM MUST WORK. GOLEM MUST HAVE A MASTER.
    “Sorry, look,” said Cheery. “Are you telling me this… thing is powered by words? I mean… is *it* telling me it’s powered by words?”
    “Why not? Words do have power. Everyone knows that,” said Angua. “There are more golems around than you might think. They’re out of fashion now, but they last. They can work underwater, or in total darkness, or knee-deep in poison. For years. They don’t need rest or feeding. They…”
    “But that’s slavery!” said Cheery.
    “Of course it isn’t. You might as well enslave a doorknob.”

The integration of more (and more-independent) Golems into society is gradual and controversial, per Making Money:

    There was another protest march going on when Moist walked to the bank. You got more and more of them lately.
    This march was against the employment of golems, who uncomplainingly did the dirtiest jobs, worked around the clock, and were so honest they paid their taxes. But they weren’t human and they had glowing eyes, and people could get touchy about that sort of thing.

Specifically it looks like he's planning to extend the ideas from https://github.com/karpathy/autoresearch into a larger effort towards recursive training improvement [1]:

> Excited to welcome Andrej to the Pretraining team! He'll be building a team focused on using Claude to accelerate pretraining research itself. I can’t think of anyone better suited to do it — looking forward to what we build together!

[1] https://x.com/nickevanjoseph/status/2056760504949842219

This is cute and retro! But I think training only on GoldenEye undersells the concept a bit, since their world model inherits the N64-era graphics from GoldenEye, which automatically makes it look dated.

If they retrained the same model on real video data, they could potentially get a multiplayer world with quite realistic-looking graphics (see https://wayve.ai/wp-content/uploads/2025/11/Ex-2-GAIA-3.mp4, https://wayve.ai/wp-content/uploads/2025/11/Ex-3-GAIA-3.mp4).

Maybe for Agora-2 :)

Right now there is (AFAIK) no world model product booking any meaningful revenue. So there's a decent chance WMs turn out to have no long-term utility at all.

However, there are a few promising markets, assuming WMs continue to get better and cheaper:

1. Robotics training / evaluation: modern end-to-end (sensors-to-control) robot policies require simulators that are almost indistinguishable from reality. If your sim is distinguishable from reality, the evaluation metrics you get from sim don't mean anything and the policies you train in sim don't work. World models will likely be the highest-fidelity robotics simulators, since WMs are data-driven and get arbitrarily more-realistic given more data/compute. This is why so many robotics companies have WM projects [1] [2] [3] [4].

2. Video frontends for agents: in the same way that today's frontier labs are building realtime voice interfaces [5] which behave like a phone call, realtime video interfaces will behave like a video call. Early forms of this don't feel compelling IMO [6] [7], but once the models can instantly blend between rendering the agent itself, drawing diagrams/visualizations, rendering video, etc. I can see it surpassing pure voice mode.

3. Entertainment: zero-shot world generation (i.e. holodeck, genie 3; paste in an image/video/text prompt and get a world) will be a fun toy but I'm not convinced it has any long-term value. I'm more optimistic about proper narrative experiences where each scene/level is a small, carefully-crafted world (behaving like a normal film scene if you don't touch the controls, and an uncharted/TLoU-style narrative game if you do), such that the sequence of scenes builds up a larger story.

[1] https://wayve.ai/thinking/gaia-3/

[2] https://xcancel.com/Tesla/status/1982255564974641628 / https://xcancel.com/ProfKuang/status/1996642397204394179

[3] https://waymo.com/blog/2026/02/the-waymo-world-model-a-new-f...

[4] https://www.1x.tech/discover/world-model-self-learning

[5] https://thinkingmachines.ai/blog/interaction-models/

[6] https://runwayml.com/news/introducing-runway-characters

[7] https://blog.character.ai/character-ais-real-time-video-brea...

This is a HW4 Tesla on FSD 14.3.2 trying to drive into a lake five days ago (a la The Office): https://www.reddit.com/r/TeslaFSD/comments/1t9rl2u/fsd_tried..., so I would not say Tesla has solved standing water yet.

That said, FSD seems quite capable of routing around standing water in many cases (e.g. https://xcancel.com/planoken/status/2030754820462633031, https://www.reddit.com/r/TeslaFSD/comments/1pw9f2m/fsd_navig..., https://xcancel.com/BLKMDL3/status/1991862465328779317, https://xcancel.com/JVTacoma/status/2046313902749921638), so handling the remaining cases seems more like a model intelligence / data issue rather than a sensor limitation. Lidar beams generally bounce off mirrorlike surfaces without returning to the sensor, so I think all lidar would tell you about standing water is "there's something shiny/reflective within this region of the image", which you already know from cameras+headlights.

Most ONNX files are fp32, but the ONNX format actually allows fp16, int8, etc. as well (see onnx.proto for the full list of dtypes [1] - they even have fp8/fp4 these days!). I ended up switching over to fp16 ONNX models for my own web-based inference project since the quality is ~identical and page loads get 2x faster.

[1] https://github.com/onnx/onnx/blob/main/onnx/onnx.proto#L605

The source here is "CAISI Evaluation of DeepSeek V4 Pro" [1]; the US NIST ran their own benchmarks (including several internal ones) and reported the following table:

    | Domain               | Benchmark              | Model (reasoning level) |                             |                          |                       |
    |--:-------------------|------------------------|-------------------------|-----------------------------|--------------------------|-----------------------|
    |                      |                        | OpenAI GPT-5.5 (xhigh)  | OpenAI GPT-5.4 mini (xhigh) | Anthropic Opus 4.6 (max) | DeepSeek V4 Pro (max) |
    | Cyber                | CTF-Archive-Diamond    | **71%**                 | 32%                         | 46%                      | 32%                   |
    | Software Engineering | SWE-Bench Verified*    | **81%**                 | 73%                         | 79%                      | 74%                   |
    |                      | PortBench              | **78%**                 | 41%                         | 60%                      | 44%                   |
    | Natural Sciences     | FrontierScience        | **79%**                 | 74%                         | 72%                      | 74%                   |
    |                      | GPQA-Diamond           | **96%**                 | 87%                         | 91%                      | 90%                   |
    | Abstract Reasoning   | ARC-AGI-2 semi-private | **79%**                 | –                           | 63%                      | 46%                   |
    | Mathematics          | OTIS-AIME-2025         | **100%**                | 90%                         | 92%                      | 97%                   |
    |                      | PUMaC 2024             | **96%**                 | 93%                         | 95%                      | **96%**               |
    |                      | SMT 2025               | **99%**                 | 92%                         | 94%                      | 96%                   |
    | IRT-Estimated Elo    | **IRT-Estimated Elo**  | **1260 ± 28**           | 749 ± 46                    | 999 ± 27                 | 800 ± 28              |

Notably, two of the benchmarks with the biggest capability gap are CAISI-internal/private ones (CTF-Archive-Diamond, PortBench). I read this as "DeepSeek is well-tuned for public benchmarks, and less generally intelligent than GPT5.5 on held-out tasks" but a less-charitable reading would be "US government reports US models do best on benchmarks that only the US government can run".

Agent benchmarking is fraught with peril [2] and an impartial benchmarker (who disproportionately overlooks bugs/issues in their evaluation of certain models) can absolutely tilt the scales, so I would not be surprised if a PRC-led benchmarking of frontier models came to the opposite conclusion.

[1] https://www.nist.gov/news-events/news/2026/05/caisi-evaluati...

[2] https://epoch.ai/gradient-updates/why-benchmarking-is-hard

Hank Green has a video walking through how to use the timeline here https://www.youtube.com/watch?v=LyZE9VWJjDA. For me, the best experience was to click "Crew Photos Only" and then step through the photos chronologically with the arrow buttons.

For context, two days ago some users [1] discovered this sentence reiterated throughout the codex 5.5 system prompt [2]:

> Never talk about goblins, gremlins, raccoons, trolls, ogres, pigeons, or other animals or creatures unless it is absolutely and unambiguously relevant to the user's query.

[1] https://x.com/arb8020/status/2048958391637401718

[2] https://github.com/openai/codex/blob/main/codex-rs/models-ma...

AFAIK Anthropic hasn't built any image or video generation tools yet, just text/code generation. OpenAI/Google/xAI all built image/video generation teams though so it may only be a matter of time.

- The OpenBSD one is 'TCP packets with invalid SACK options could crash the kernel' https://cdn.openbsd.org/pub/OpenBSD/patches/7.8/common/025_s...

- One (patched) Linux kernel bug is 'UaF when sys_futex_requeue() is used with different flags' https://github.com/torvalds/linux/commit/e2f78c7ec1655fedd94...

These links are from the more-detailed 'Assessing Claude Mythos Preview’s cybersecurity capabilities' post released today https://red.anthropic.com/2026/mythos-preview/, which includes more detail on some of the public/fixed issues (like the OpenBSD one) as well as hashes for several unreleased reports and PoCs.

My impression was entirely the opposite; the unsolved subset of SWE-bench verified problems are memorizable (solutions are pulled from public GitHub repos) and the evaluators are often so brittle or disconnected from the problem statement that the only way to pass is to regurgitate a memorized solution.

OpenAI had a whole post about this, where they recommended switching to SWE-bench Pro as a better (but still imperfect) benchmark:

https://openai.com/index/why-we-no-longer-evaluate-swe-bench...

> We audited a 27.6% subset of the dataset that models often failed to solve and found that at least 59.4% of the audited problems have flawed test cases that reject functionally correct submissions

> SWE-bench problems are sourced from open-source repositories many model providers use for training purposes. In our analysis we found that all frontier models we tested were able to reproduce the original, human-written bug fix

> improvements on SWE-bench Verified no longer reflect meaningful improvements in models’ real-world software development abilities. Instead, they increasingly reflect how much the model was exposed to the benchmark at training time

> We’re building new, uncontaminated evaluations to better track coding capabilities, and we think this is an important area to focus on for the wider research community. Until we have those, OpenAI recommends reporting results for SWE-bench Pro.

Here was the developer thread https://developer.apple.com/forums/thread/818403 I found with lots of other reports of "Unable to Verify App - An internet connection is required to verify the trust of the developer".

Although https://developer.apple.com/system-status/ was green for most of the 3-4 hour outage, the page now at least acknowledges two minutes of downtime:

    App Store Connect - Resolved Outage
    Today, 12:04 AM - 12:06 AM
    All users were affected
    Users experienced a problem with this service.

Not a great developer experience.