lairv

Not exactly what you describe but this project [0] did it with cubes.

The cube is filled with splats. Each face reveals a different picture when viewed from a perpendicular angle

[0] https://www.3dpoint.art/

This is "old" news from February but somehow hasn't been discussed here

For a space that supposedly had "no moat", the number of players still competing for frontier models seems to be shrinking pretty fast

Wikipedia says there's 14.8 billion videos currently uploaded to YouTube, it seems technically easy to index that amount of title+description?

The more likely explanation is that Google doesn't want YouTube to be crawled, which gives them a massive moat for AI training

Worth noting that most of youtube videos can no longer be discovered through search. Search results can now only be sorted by "Relevance" and "Popularity" while you used to be able to sort by release date

Search results are also non-exhaustive and biased towards recent videos as noted in this study https://arxiv.org/abs/2506.11727

Basically many videos can no longer be discovered if you don't have a url to the video or the channel, and the algorithm doesn't recommend it

If the model is truly on par with Opus 4.6/Gemini 3.1/GPT 5.4 (beyond benchmarks) this still puts MSL in the frontier lab category, which is no small feat given that they pretty much rebooted last year

Many labs aren't able to keep up with the frontier, xAI, Mistral

Note that this uses a harness so it doesn't qualify for the official ARC-AGI-3 leaderboard

According to the authors the harness isn't ARC-AGI specific though https://x.com/agenticasdk/status/2037335806264971461

Blank screen, and it's referenced in the official docs as potentially a Wayland issue https://opencode.ai/docs/troubleshooting/#linux-wayland--x11...

I didn't dig further

Seems like there's many github issues about this actually

https://github.com/anomalyco/opencode/issues/14336

https://github.com/anomalyco/opencode/issues/14636

https://github.com/anomalyco/opencode/issues/14335

This issue: https://github.com/anomalyco/opencode/issues/9505

And then the official docs: https://opencode.ai/docs/troubleshooting/#linux-wayland--x11...

Linux: Wayland / X11 issues

On Linux, some Wayland setups can cause blank windows or compositor errors.

If you’re on Wayland and the app is blank/crashing, try launching with OC_ALLOW_WAYLAND=1.

If that makes things worse, remove it and try launching under an X11 session instead.

OC_ALLOW_WAYLAND=1 didn't work for me (Ubuntu 24.04)

Suggesting to use a different display server to use a TUI (!!) seems a bit wild to me. I didn't put a lot of time into investigating this so maybe there is another reason than Wayland. Anyway I'm using Pi now

I tried to use it but OpenCode won't even open for me on Wayland (Ubuntu 24.04), whichever terminal emulator I use. I wasn't even aware TUI could have compatibility issues with Wayland

https://cims.nyu.edu/dynamic/news/1441/

This is just the official name of a chair at NYU. I'm not even sure Jacob T. Schwartz is more well known than Yann LeCun

Truly amazing that they've managed to build an open and profitable platform without shady practices

Default to "spawn" is definitely the right thing, it avoids many footguns

That said for PyTorch DataLoader specifically, switching from fork to spawn removes copy-on-write, which can significantly increase startup time and more importantly memory usage. It often requires non-trivial refactors, many training codebase aren't designed for this and will simply OOM. So in practice for this use case, I've found it more practical to just use pandas rather than doing a full refactor

Well I think ProcessPoolExecutor/ThreadPoolExecutor from concurrent.futures were supposed to be that

I would agree if not for the fact that polars is not compatible with Python multiprocessing when using the default fork method, the following script hangs forever (the pandas equivalent runs):

    import polars as pl
    from concurrent.futures import ProcessPoolExecutor

    pl.DataFrame({"a": [1,2,3], "b": [4,5,6]}).write_parquet("test.parquet")

    def read_parquet():
        x = pl.read_parquet("test.parquet")
        print(x.shape)

    with ProcessPoolExecutor() as executor:
        futures = [executor.submit(read_parquet) for _ in range(100)]
        r = [f.result() for f in futures]

NVIDIA stock tanked in 2025 when people learned that Google used TPUs to train Gemini, which everyone in the community knows since at least 2021. So I think it's very likely that NVIDIA stock could crash for non-rationale reasons

edit: 2025* not 2024

That's why I always disliked calling null the "billion dollar mistake", null and Options<T> are basically the same, the mistake is not checking it at compile time

Is there a solution to this exact problem, or to related notions (renewal equation etc.)? Anyway seems like nothing beats training on test

Out of curiosity, I gave it the latest project euler problem published on 11/16/2025, very likely out of the training data

Gemini thought for 5m10s before giving me a python snippet that produced the correct answer. The leaderboard says that the 3 fastest human to solve this problem took 14min, 20min and 1h14min respectively

Even thought I expect this sort of problem to very much be in the distribution of what the model has been RL-tuned to do, it's wild that frontier model can now solve in minutes what would take me days

For those curious here are the actual keywords (from https://docs.python.org/3/reference/lexical_analysis.html?ut... )

Hard Keywords:

False await else import pass None break except in raise True class finally is return and continue for lambda try as def from nonlocal while assert del global not with async elif if or yield

Soft Keywords:

match case _ type

I think nonlocal/global are the only hard keywords I now barely use, for the soft ones I rarely use pattern matching, so 5 seems like a good estimate

I'm also curious what's the use case of this over Ray. Tighter integration with PyTorch/tensors abstractions?

From the docs ( https://meta-pytorch.org/monarch/index.html ):

Monarch is a distributed programming framework for PyTorch based on scalable actor messaging. It provides:

- Remote actors with scalable messaging: Actors are grouped into collections called meshes and messages can be broadcast to all members.

- Fault tolerance through supervision trees: Actors and processes for a tree and failures propagate up the tree, providing good default error behavior and enabling fine-grained fault recovery.

- Point-to-point RDMA transfers: cheap registration of any GPU or CPU memory in a process, with the one-sided tranfers based on libibverbs

- Distributed tensors: actors can work with tensor objects sharded across processes

It seems like the goal of Monarch is to do what Ray does, but more tightly integrated with the Deep Learning/distributed training ecosystem?

https://nautil.us/deep-learning-is-hitting-a-wall-238440/

Gary Marcus said that Deep Learning was hitting a wall 1 month before the release of DALLE 2, 6 months before the release of ChatGPT and 1 year before GPT4, arguably 3 of the biggest milestones in Deep Learning

Do you just type with a regular keyboard then?

I had a similar idea when apple vision pro came out, to be able to code while laying on a couch or bed fully relaxed, but never got to doing it. Neat!

(I'm the one who posted the url, not author post)

Julian Schrittwieser (author of this post) has been in AI for a long time, he was in the core team who worked on AlphaGo, AlphaZero and MuZero at DeepMind, you can see him in the AlphaGo movie. While it doesn't make his opinion automatically true, I think it makes it worth considering, especially since he's a technical person, not a CEO trying to raise money

"extrapolating an exponential" seems dubious, but I think the point is more that there is no clear sign of slowing down in models capabilities from the benchmarks, so we can still expect improvements

If you refresh you get simpler ones, like the couple kissing

We know that they correctly implement their specification*

on the contrary this makes me bullish about their team, it shows that people here care about the craft

I don't remember the last time I was surprised by a car approaching from behind.

With a headwind I often don’t hear cars behind me at all, so I can see the use case