gavinray

Best sounding local TTS engine I've heard by far is Kokoro

It's small enough to be run on modern phones realtime, I use it for listening to PDF's/EPUB as Audiobooks

https://huggingface.co/hexgrad/Kokoro-82M

  > because the wilderness is behind 3 confirmation screens

Some of the earliest social/life lessons I learned were through interactions in that game

Today's youth will never re-live the experience of having someone tell you to "follow them to hidden area" and then one-hitting you with a rune weapon the second you crossed into wildy + taking all your shit.

I found the YouTube video the other day and enjoyed watching it.

The agent pathing seemed to clip a bit through the sides of mountains at times though -- or maybe that is just a bug of GM camera following player?

Because telling lies on the internet attached to my real name is so beneficial to my reputation, right?

https://i.imgur.com/CNAUczi.png

I lost my ability to fully explain the systems I work on around the time I transitioned from next-edit-prediction AI running in my IDE (early Copilot) and working primarily via Codex/Claude CLI's.

The further away I got from the implementation details, the fuzzier the semantics became. To the point that now I could not in good faith say I understand the system I have built from the ground-up and worked on the last ~4-5 years.

The solution to this, in my mind, is not to revert back to reviewing implementation details. The economics of that from a business/productivity perspective don't play out well.

The only viable solution in my mind is adapting code/languages themselves to the shift by making programs formally verifiable. That way you can be sure that the code "does what it says on the tin", and provably so.

I feel so strongly about this I've written on it:

https://gavinray97.github.io/blog/design-by-contract-and-eff...

  > Self-improving code would be code that runs itself and improves itself.

I don't find the description any less accurate than saying that a JIT'ed application is self-improving code.

  > "... for the harnesses we have seen in these campaigns, average success rate is hovering around 10%"

A 10% success rate is absurd.

Just got an email that I now have access to Mythos:

  > "Your Cyber Verification Program access now includes Claude Mythos 5.1, Claude Opus 5.5, and Claude Sonnet 5.5."

This was a lot more exciting than I expected.

The homepage does not do a very good job of explaining what we're looking at:

It appears to be a combination of two things:

1) A formalization of the Python language

2) An LLM which hooks into running programs and hot-swaps code with verifiably-equivalent behavior but better runtime performance, found via superoptimization and then verified via the formalization rules

This is brilliant, and in hindsight one of those "I can't believe nobody had thought of this yet" sort of things.

Here's the transcription of the reasoning:

  > Hangzhou DeepSeek Artificial Intelligence Basic Technology Research Co., Ltd. (hereinafter DeepSeek), a foreign, privately-owned company, located in the People’s Republic of China (PRC) provides multiple artificial intelligence applications available widely and free of charge. DeepSeek’s models present multiple threat vectors. DeepSeek servers are located in the PRC, and the PRC legal system permits extensive authority to government cyber and intelligence functions to access private company infrastructure. For DeepSeek-hosted instances of their models, DeepSeek’s account generation process collects personally identifiable information (PII) and may also track and digitally fingerprint users. DeepSeek’s most widely used applications function through a prompt-and-response process that requires presenting information to the model, and which may result in the transfer of sensitive data to the PRC if used by U.S. government employees or vendors. The transfer of the aforementioned information to the PRC, either independently or in combination with publicly available data, could produce actionable intelligence on U.S. persons and/or government programs. The models themselves may contain malware or other security vulnerabilities. Indeed, open-source security research has found that the DeepSeek iOS mobile application contains multiple critical vulnerabilities.

Kiwi and Boba (tea)

If you take this question far enough, you eventually reach a core philosophical debate:

"Does it matter what anything innately is, beyond the effects it has on you?"

For example: Suppose you were given a human companion with a robot brain that was your ideal friend. They made you laugh and you enjoyed every moment you spent with them.

Does it make it any less impactful/genuine to you that they're not a "real" human, or is your felt experience the only meaningful end-measure?

For me, it's the latter.

  > Spamming the government, using a sick mother as leverage and threatening the small claims court.

Here I am uncomfortable with telling the waiter I didn't want lettuce on my burger...

As another person commented, we currently believe the primary mechanism behind the pleitropic effects of GLP-1's to be a reduction in systemic inflammation and direct improvements in vascular/endothelial function.

The best paper I've seen on this was the recently published and very aptly named:

"Pleiotropic effects of GLP-1 receptor agonists — a narrative review of extra-metabolic outcomes in adults" (2026)

https://journals.viamedica.pl/medical_research_journal/artic...

Possibly the best and most succinct explanation in the thread thus far.

Random tidbit: I wrote a GCC compiler plugin years ago to add Contracts to C/C++ while waiting for this to make it into the standard

https://gavinray97.github.io/blog/adding-invariant-to-cpp-de...

The post turned out to be more useful for an intro to writing GCC plugins than anything, but at least I had fun

If you enjoy this style of programming, I wrote a bit on why contracts and capabilities (ie "allocates memory", "performs i/o") are going to become essential for LLM generated code:

https://gavinray97.github.io/blog/design-by-contract-and-eff...

Just an FYI: You can do this with an email

Email allows "+<suffix>" to be appended to any email.

The usual case is something like "user+testing@site.com", or "user+bills@site.com".

It's a way to auto-tag your incoming mail. You can use one of these "+" suffixes on a per-app basis and then add a spam filter to permanently burn one of them if you get spammed.

I do, solely on the basis of "there are a lot of smart(er) people in the world, and very few truly novel problems".

The first step in approaching anything difficult is seeing whether someone else has already solved it.

Unironically, give your aggregate health records (office visits, bloodwork results, etc) to an LLM and you're likely to get better advice.

Upvotes and Twitter hype

  >  I run into problems, figure out solutions that don't seem to be documented anywhere else, and then I don't post about them.

I don't understand this. Presumably you've only been able to build software your entire career because, when you hit a wall, usually someone online had too and shared the solution.

This feels like throwing a sandwich in the trash rather than let a hungry person eat it.

The content of these articles seems to be "the Iran war is bad for Americans", which is not propaganda though?

The performance is impaired by the Rust port re-implementing Go-style strings and a good portion of the Go std library.

It's jumping through hoops to preserve initial Go semantics:

https://github.com/pingdotgg/ts-rust/blob/main/crates/ts_gop...

https://github.com/pingdotgg/ts-rust/tree/main/crates/ts_gop...

For what it's worth, I have Community Notes access on Twitter, and the below is a currently-hidden note for the post which in the "validation gathering" phase:

  > The shown benchmarks use non-equivalent implementations: Elixir routes all DB queries through a single GenServer with Redis for jobs (retained from Rails), while Rust uses in-process queues, omits CSRF tags/fields, and applies other caching changes.

https://x.com/zachsdaniel1/status/2106820451557073175

https://github.com/basecamp/once-campfire-elixir/blob/main/l...

https://raw.githubusercontent.com/basecamp/once-campfire-eli...

https://github.com/basecamp/once-campfire-rust

https://github.com/basecamp/once-campfire

[flagged]

It's entirely real.

https://www.slutcon.com/

Did anyone read the blogpost? They did publish a pre-print:

  > Our work to understand the primary function of ARTs is ongoing. However, we think it is important to share such findings early, both to demonstrate Claude’s capabilities and to give the broader community insight into what we’re working on. We have released a pre-print (here) that discusses this in more detail.

https://www-cdn.anthropic.com/22573675ada52a8ca8a97a1a4b4326...

  > "I think people generally choose Deno because of the stability and security-first architecture."

The appeal of Deno to me was always it's Go-like `std` library, so that building basic apps didn't result in a spaghetti web of dependencies like in Node.