Scaevolus

Paying 0.055 EUR per GB of traffic sent to French residents makes video streaming fundamentally unprofitable.

Rather than loading the raw approximate decompile code into SQLite, you'll likely get better results using Ghidra directly with tool calls through an MCP adapter. This is especially important when the analysis tracing fails, like with some complex indirect jump patterns with vtables. Xrefs and pattern searches are of course natively supported, and you can load in memory snapshots.

A simple "/goal analyze this codebase, assign names for each function, and creates named structs for parameters." works well, even with quite weak agents. Remember, parsing through heaps of text is their forte!

This setup also works for more exotic non-x86 architectures with more dynamic code loading, like PS2, N64, etc.

"Honesty" is what crossed the threshold for me. It's pretty weird to spend 12 years on something and not bother to write the thousand word history yourself.

Making scalable source control is much easier when you can rely on a distributed database (Spanner) and object storage (GCS/S3/...)!

Reverse engineering and decompilation is not currently blocked by the models, leading to the proliferation of LLM-assisted decomps/recomps. If you ask it to find bugs you're more likely to get a refusal, but simply pointing an LLM at a Ghidra MCP server and telling it to trace program flow, rename functions, or answer questions behaves like normal.

I agree on active devices, and most of the ecosystem is similarly frustrating to deal with.

And why rely on someone else's software for this in 2026? I vibecoded a Rust+Starlark zigbee hub software that uses a few MB of RAM on my router and can directly dispatch HTTP for alerting, as well as exposing prometheus metrics. Zigbee2MQTT apparently wants several hundred MB of RAM.

For passive monitoring, I have six water leak sensors and two temperature/humidity sensors.

The crucial thing is that I can fix it if it breaks. I can debug the low level network packets, support whatever hardware I want, and not have to rely on someone else's cloud ecosystem.

It's great!

Wine-style PS5 emulation has advanced far enough that I would bet money on there being a pirated GTA6 PC release based on the PS5 version available within six months.

Given how women initiate most divorces, it's probably best to set it up so they are the proposing side.

But this isn't raw Gale-Shapley-- the participants aren't ranking all hundreds/thousands of others. In particular, the preference matrix is based on identical mutual compatibility scores, so there's a unique stable solution (not multiple stable ones!), and there's no "side" that benefits, since the solution is identical no matter who does the "proposing".

It creates multiple versions of functions referencing SIMD and lifts the dispatch switching cost to their callers.

> The AST rewrite creates multiple specialized copies of functions, variables, and types that mention simd types, where simd types are replaced with references to size-specialized types in simd/internal/bridge. Each of these bridge types is defined as an archsimd type, but with a restricted set of methods. The specialized functions, variables, and types acquire a suffix of the form @simdNNN, where NNN is either a vector length (128, 256, or 512) or 0, indicating emulation. Functions that mention simd internally, but not in their signature, are converted to wrappers that switch on the SIMD level detected at program start, and call the appropriate specialized version of that function. Specialized functions call other specialized functions directly without dispatch overhead (and perhaps with inlining). This rewrite strategy was chosen as a compromise between code duplication and SIMD performance; the overhead is hoisted as high as necessary to avoid dispatch within SIMD computations, but not higher. If SIMD dispatch appears “too low” in a computation, a gratuitous mention of a simd type will move it upwards, as in this example:

This is a solid improvement over Needle 2, which I tried using for a tool-calling interface to a Runescape database site. Unfortunately it's still not quite capable enough for my target compared to FunctionGemma.

   Model                            Correct tool shape    Exact arguments
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  ━━━━━━━━━━━━━━━━━━━━  ━━━━━━━━━━━━━━━━━
   FunctionGemma fine-tune, BF16       209/230 (90.9%)    196/230 (85.2%)
  ───────────────────────────────  ────────────────────  ─────────────────
   Needle 3 fine-tuned W4A8             74/230 (32.2%)     47/230 (20.4%)
  ───────────────────────────────  ────────────────────  ─────────────────
   Needle 2 fine-tuned W4               59/230 (25.7%)     43/230 (18.7%)

It also compares the total time for jxl-rs's benchmark mode (which does a warmup and a test decode) for 16-bit RGB against 8-bit WebP to 4:2:0 YUV.

Engineers understand that every technology represents inherent tradeoffs.

Aside: if you want a source of high quality Piano MIDI recordings, you should check out the MAESTRO dataset: https://magenta.withgoogle.com/datasets/maestro

> The dataset contains about 200 hours of paired audio and MIDI recordings from ten years of International Piano-e-Competition. The MIDI data includes key strike velocities and sustain/sostenuto/una corda pedal positions. Audio and MIDI files are aligned with ∼3 ms accuracy and sliced to individual musical pieces, which are annotated with composer, title, and year of performance. Uncompressed audio is of CD quality or higher (44.1–48 kHz 16-bit PCM stereo).

Did you try blender MCP and prompt for low-poly vertex colored assets?

GPT-6 has a looped transformer / recurrent depth architecture, so it gets some internal CoT reasoning "for free" with no output tokens.

This also makes it much harder to monitor its reasoning.

See Cursor's recent blog post on launching a Github competitor, particularly the architectural history.

Chrome doesn't use hardware acceleration for decoding any image codecs-- not for JPEG or WebP or AVIF. It has some code for it (using VA-API), but it's disabled by default. Hardware video decoders are generally hard to use for image decoding tasks.

Safari appears to be the only shipping browser using hardware decoding for JPEG and HEIF (HEVC based images). This is probably because vertical integration lets them make the decoders appropriate for image use.

Also, "AVIF video" is incorrect. AVIF is the image codec based on AV1 intra frames.

"delivering up to 750 output tokens per second and without any quality compromise" seems pretty definitive.

- it's easy to prompt an LLM to do it for you, especially if you're targeting a pre-existing runtime like CLR or transpiling to another language. previously you'd have to grind out the parser and compiler for a new language, but a lot of that work is mechanical

- "I want a language that works a little differently"

- programming language theory (PLT), generally

- languages are tools. the authors should explain what their languages are best suited for

- Obj C and C++ were both developed around the same time as extensions of C. Obj C was focused on message passing and Smalltalk's object system, while C++ was focused on adding as many abstractions as possible to C. Neither language has good support for avoiding null pointer dereferences, one of the primary things Swift addresses with its richer type system and Optionals.

BitTorrent's bencoding format, used in .torrent files, effectively uses netstrings-- but without the trailing commas, so it uses "5:hello" to represent filenames and similar.

It's not really a big problem. You should be storing arbitrary binary strings as blobs (and length() works properly with them), but the underlying encoding is nearly identical: https://www.sqlite.org/fileformat.html#record_format

if you happen to regenerate your protos 5 times in an hour you'll get ratelimited

it's a very frustrating system. you should spend a modicum of effort figuring out how to generate your things locally yourself instead, be that docker, arcane wasm...

The absolutely easiest way to write a JIT is to use Javascript and eval() (or "new Function()", which is just eval in a Java-shaped tuxedo). You can quite easily speed up little matching functions, especially arithmetic heavy ones, by just filling in some templates at runtime!

Here's an example used in PuzzleScript: https://github.com/increpare/PuzzleScript/blob/dc1e0fc979365...

Cloudflare's Deepseek V4 Pro prices are 4x more than Deepseek's for input and output tokens, and 100x more for cached input tokens, which is crucial for the tool uses of agents which cause multi-turn conversations.

Something like https://www.kythe.io/?

It's rgb with 3.3 bits per channel, basically 10 bit per pixel color (256 colors is 8bpp).

Sqlite can quite easily do 5000+ insert+commits per second on typical NVMe drives.

Speed is rarely the constraint that makes it unsuitable for an application.

The main thing holding most people back from web-based IDEs is restricted filesystem and tools integrations, but cloud office suites are extremely popular. Google has excellent infrastructure for distributed build and test cycles built into Cider to go along with the entirely remote version control system.

Best of luck on your web-based demos! Dropping people into a working dummy environment with a few tutorial prompts should really help conversions.

I see you have ALP, but have you tried Chimp128 or Arrow's byte stream split?

Apple could easily support eGPUs if they wanted to, but they choose to have vertical integration over fragmentation or usefulness. It's the same as them not supporting OpenGL or Vulkan: they could if they wanted to be a better gaming/porting target, but compatibility of any sort is not a priority.