anonova

vLLM's study also concluded that "FP8 can deliver meaningful latency and capacity gains with small or negligible accuracy loss". Their benchmarks include LiveCodeBench 6.

https://vllm-project.github.io/2026/04/22/fp8-kvcache.html

Can confirm that this started happening today.

> Log in to use old Reddit

> To keep Reddit safe, accounts are required to access old Reddit. Log in, or continue without an account on reddit.com.

I don't participate in Reddit conversions and only use old.reddit.com to browse some specific subreddits as a guest.

Literal music videos are still fun and a valid creative direction, e.g., Vance Joy's "Riptide": https://www.youtube.com/watch?v=uJ_1HMAGb4k

Grit was the name of a _Ruby_ implementation of git way back when: https://github.com/mojombo/grit/. I believe it's actually what GitHub was built on then.

Do Gemma 4 models compete with Gemini 3.1 Flash-Lite? I would assume even the smallest Gemini model would outperform even Gemma 4 31B, but I can't really get a sense of performance or output quality difference.

There's a comparison of all the Gemma 4 models (+ Gemma 3 27B) on the Huggingface model card: https://huggingface.co/google/gemma-4-12B-it#benchmark-resul...

A Qwen research member had a poll on X asking what Qwen 3.6 sizes people wanted to see:

https://x.com/ChujieZheng/status/2039909917323383036

Likely to drive engagement, but the poll excluded the large model size.

Local-only usage of Termius is free and doesn't even require logging in to the service. I've been using it like this for years.

For your first point, I'd recommend using Krita (https://krita.org/) and its generative AI plugin: https://github.com/Acly/krita-ai-diffusion / https://www.interstice.cloud/

Note that this kind of visualization is just the collapsed form of a standard forecast graph, e.g.

https://forecast.weather.gov/MapClick.php?lat=37.39&lon=-122...

https://www.wunderground.com/forecast/us/ca/mountain-view

I was excited for this one to replace a bunch of single type Box<dyn Trait> returns, but there are still quite a few limitations using -> impl Trait in traits in general. It's still discouraged to use them in public APIs: https://blog.rust-lang.org/2023/12/21/async-fn-rpit-in-trait...

This has been around for a long time called Peter Answers as a modern take on the Ouija. See, e.g., https://www.peter-virtual-tarot.com/

I wouldn't be surprised if this is more a legal issue since Microsoft was granted a patent on rANS encoding, which is used in JPEG-XL: https://www.theregister.com/2022/02/17/microsoft_ans_patent/

> at least for now

Yep, the aarch64-nintendo-switch-freestanding target will (very likely) be available in Rust 1.64.0 [0].

[0]: https://github.com/rust-lang/rust/pull/88991#issuecomment-11...

> An user friendly editor should pop some kind of prompt when I pressed the first g/G key and show me what I could press the next,

See vim-which-key [1] and which-key.nvim [2] for something similar to this.

[1]: https://github.com/liuchengxu/vim-which-key

[2]: https://github.com/folke/which-key.nvim

A detailed analysis of Meow Hash: https://peter.website/meow-hash-cryptanalysis

It's not the highest of quality hash functions (see the SMHasher benchmarks), but it is fast. A great alternative is XXH3 (https://cyan4973.github.io/xxHash/), which has seen far more usage in practice.

No releases for 17 yet, but checking the site, I discovered that AdoptOpenJDK was moved to the Eclipse Foundation and renamed to Adoptium: https://adoptium.net/

An officially supported Rust SDK should be a high priority, IMO. The de facto AWS library Rusoto (https://github.com/rusoto/rusoto) went into maintenance mode is in need of maintainers (https://github.com/rusoto/rusoto/issues/1651).

Microsoft has an Azure SDK under their organization (https://github.com/Azure/azure-sdk-for-rust), but oddly, it's marked as "unofficial". It looks like Google doesn't have one for GCP, but there is a community-built one: https://github.com/Byron/google-apis-rs

Given all these companies are part of the Rust Foundation (https://foundation.rust-lang.org/members/), maybe I just expect more.

After buying a transmitter/controller, Liftoff (https://store.steampowered.com/app/410340/) is a great simulation to learn how to fly.

Adaprox has various "finger bots" for those who don't want to build their own: https://www.adaprox.io/

Yes, it was introduced in Ruby 2.6 (2018): https://www.ruby-lang.org/en/news/2018/12/25/ruby-2-6-0-rele...

From benchmarks [1], 2.8.0 (with jit) is ~2x faster than 2.0.0p648 [2].

[1]: https://pragtob.wordpress.com/2020/08/24/the-great-rubykon-b...

[2]: https://pragtob.wordpress.com/2017/01/24/benchmarking-a-go-a...

> I've never seen someone who wants to go back from TypeScript to plain JavaScript.

This is a very specific case, but it can happen: https://github.com/denoland/deno/pull/6793

I find it absolutely frustrating that Rust packaging/crates.io doesn't support namespaces. The arguments I've read are always theoretical/what ifs, but I've yet to be convinced the current situation is better than the practical benefits of namespaces.

Which is funny too because GitHub repos have Docker repository functionality: https://github.com/features/packages

But since its release, you still can't do public pulls: https://github.community/t/docker-pull-from-public-github-pa...

Yes, I didn't expect to see popup windows, which seems to a be a direct response to Neovim's floating windows (https://twitter.com/Neovim/status/1101879098044043264).

I was looking for a small image processing library (as opposed to libMagickWand) and came across libvips [1]. I found it absolutely bizarre that the public API in a C library was full of variadic functions to support optional arguments. The last argument to most function calls is required to be NULL to denote the end of the argument list, e.g., https://libvips.github.io/libvips/API/current/using-from-c.h... (vips_image_new_from_file, vips_invert, etc.).

[1]: https://libvips.github.io/libvips/

Yep, Native Instruments (on that list) sent out an explicit email saying not to update: https://support.native-instruments.com/hc/en-us/articles/360...

I was under the impression that it wasn't for performance but for distribution, i.e., to optimize for app size. Instead of having a fat binary crosscompiled for different architectures, Apple uses the bitcode to compile and distribute per architecture. It's part of the "app thinning" process.

Yes, this is ones of my problems with Julia. It seems to be optimized for long runs and REPL/notebook usage.

Take, for example, a simple program that creates a line plot (https://docs.juliaplots.org/latest/tutorial/):

    using Plots
    x = 1:10
    y = rand(10)
    plot(x, y)

After installing the package, the first run has to precompile(?), and subsequent runs use the package cache. But ~25 s to create a simple plot is incredibly slow and frustrating to work with.

    $ julia --version
    julia version 1.1.1
    $ time julia plot.jl
    julia plot.jl  73.71s user 4.45s system 110% cpu 1:11.04 total
    $ time julia plot.jl
    julia plot.jl  24.41s user 0.39s system 100% cpu 24.633 total
    $ time julia plot.jl
    julia plot.jl  23.38s user 0.36s system 100% cpu 23.519 total