State of AI: An Empirical 100T Token Study with OpenRouter https://openrouter.ai/state-of-ai
OpenRouter
State of AI 2025: 100T Token LLM Usage Study | OpenRouter
Read OpenRouter's comprehensive 2025 State of AI report — an empirical 100 trillion token study of real LLM usage, model trends, and developer ecosystem insights.
Daniel Lemire's blog
How fast can browsers process base64 data?
source
How fast can browsers process base64 data?
source
Daniel Lemire's blog
How fast can browsers process base64 data?
Base64 is a binary-to-text encoding scheme that converts arbitrary binary data (like images, files, or any sequence of bytes) into a safe, printable ASCII string using a 64-character alphabet (A–Z, a–z, 0–9, +, /). Browsers use it in JavaScript to embedding…
https://sites.google.com/view/dpc4-2026/
4th Data Prefetching Championship 2026
4th Data Prefetching Championship 2026
Migrating the Main Zig Repository from GitHub to Codeberg https://ziglang.org/news/migrating-from-github-to-codeberg/
Chips and Cheese
Evaluating Uniform Memory Access Mode on AMD's Turin ft. Verda (formerly DataCrunch.io)
#ChipAndCheese
Telegraph | source
(author: Chester Lam)
Evaluating Uniform Memory Access Mode on AMD's Turin ft. Verda (formerly DataCrunch.io)
#ChipAndCheese
Telegraph | source
(author: Chester Lam)
Daniel Lemire's blog
How good are Chinese CPUs? Benchmarking the Loongson 3A6000
source
How good are Chinese CPUs? Benchmarking the Loongson 3A6000
source
Daniel Lemire's blog
How good are Chinese CPUs? Benchmarking the Loongson 3A6000
I maintain a few widely used libraries that have optimized code paths based on the specific processor being used. We started supporting Loongson processors in recent years, but I did not have access to a Loongson processor until now. To my knowledge, they…
Zig Builds Are Getting Faster – Mitchell Hashimoto
https://mitchellh.com/writing/zig-builds-getting-faster
https://mitchellh.com/writing/zig-builds-getting-faster
Chips and Cheese
SC25: HACCing over 500 Petaflops on Frontier
#ChipAndCheese
Telegraph | source
(author: George Cozma)
SC25: HACCing over 500 Petaflops on Frontier
#ChipAndCheese
Telegraph | source
(author: George Cozma)
Chips and Cheese
Qualcomm’s Snapdragon X2 Elite
#ChipAndCheese
Telegraph | source
(author: George Cozma)
Qualcomm’s Snapdragon X2 Elite
#ChipAndCheese
Telegraph | source
(author: George Cozma)
Daniel Lemire's blog
AMD vs. Intel: a Unicode benchmark
source
AMD vs. Intel: a Unicode benchmark
source
Daniel Lemire's blog
AMD vs. Intel: a Unicode benchmark
Roughly speaking, our processors come in two types, the ARM processors found in your phone and the x64 processors made by Intel and AMD. The best server processors used to be made by Intel. Increasingly, Intel is struggling to keep up. Recently, Amazon has…
Five Years of Apple Silicon: M1 to M5 Performance Comparison - MacRumors https://share.google/4VsFpfpjeuiZdWPYA
MacRumors
Five Years of Apple Silicon: M1 to M5 Performance Comparison
Today marks the fifth anniversary of the Apple silicon chip that replaced Intel chips in Apple's Mac lineup. The first Apple silicon chip, the M1, was unveiled on November 10, 2020. The M1 debuted in the MacBook Air, Mac mini, and 13-inch MacBook Pro.
Daniel Lemire's blog
Automated Equality Checks in C++ with Reflection (C++26)
In C++, comparing two objects for equality is straightforward when they are simple types like integers or strings. But what about complex, nested structures? You may have to implement the comparison (
Consider a
To compare two
Without reflection, you would hae to write something ugly of the sort.
But this assumes
Instead, I wrote a small example that fully automates the process. You just add an operator overload.
The trick is that C++26 allows you to query a type’s members at compile time and iterate over them. The function
My complete implementation is less than a hundred lines of code, and it comes down to the following lines of code.
It relies on the reflection operator
The approach ensures zero runtime overhead, as all reflection, splicing, and looping are resolved during compilation. I posted a full demonstration.
source
Automated Equality Checks in C++ with Reflection (C++26)
In C++, comparing two objects for equality is straightforward when they are simple types like integers or strings. But what about complex, nested structures? You may have to implement the comparison (
operator==) manually for each class, which is error-prone and tedious.Consider a
person class.class person {
public:
person(std::string n, int a) : name(n), age(a) {}
private:
std::string name;
int age;
std::vector<hobby> hobbies;
std::optional<uint64_t> salary;
};
To compare two
person objects, we need to check if their names, ages, hobbies, and salaries match. Hobbies are a vector of hobby objects, each with a name. Salaries are optional. Manually writing operator== for this would involve checking each field, and if hobby changes, you would have to update it.Without reflection, you would hae to write something ugly of the sort.
bool operator==(const person& a, const person& b) {
return a.name == b.name && a.age == b.age && a.hobbies == b.hobbies && a.salary == b.salary;
}
But this assumes
hobby has operator==, and std::vector<hobby> has it only if hobby does. If hobby lacks ==, compilation fails. Moreover, for large classes, it becomes annoying.Instead, I wrote a small example that fully automates the process. You just add an operator overload.
bool operator==(const person& a, const person& b) {
return deep_equal::compare(a, b);
}
The trick is that C++26 allows you to query a type’s members at compile time and iterate over them. The function
std::meta::nonstatic_data_members_of, which gives us a list of members.My complete implementation is less than a hundred lines of code, and it comes down to the following lines of code.
bool compare_same(const T& a, const T& b) {
template for (constexpr auto mem : std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
if (!compare_same(a.[:mem:], b.[:mem:])) {
return false;
}
}
return true;
}
It relies on the reflection operator
^^T, which produces a std::meta::info value representing the type itself. Inside the function body, std::meta::nonstatic_data_members_of(^^T, ...) queries all non-static data members of T, returning a vector of reflection values in declaration order. The unchecked access context deliberately bypasses visibility rules, allowing comparison of private and protected members. This reflection vector is then wrapped in std::define_static_array, which materializes it into a static array, making it iterable in a compile-time loop. The template for loop iterates over each member reflection mem at compile time. For each, the splice expression a.[:mem:] directly accesses the corresponding member. The [: :] is more or less the inverse of the reflection operator (^^T): think of it as a going into a meta universe with ^^ and coming back into the standard C++ universe with [: :].The approach ensures zero runtime overhead, as all reflection, splicing, and looping are resolved during compilation. I posted a full demonstration.
source
