Even with the models as good at cyber as they are, even with as much fuzzing and inference already thrown at foundational code bases, still there are bugs. With model assistance, I found 2 segfaults and 3 bugs in AWS-LC yesterday. Thanks AWS folks for taking my bugs and fixes!

Other than the `P` and `p` directives to Array#pack#, @artichokeruby's Array is now 100% ruby/spec compliant Finger to the wind I am 82% done. The Artichoke you see in public, as it exists in its archived state on GitHub, is 15% done.

TIL [4.0.9] > predicate = Kernel.instance_method(:nil?) => #nil#?()> [4.0.9] > predicate.bind_call(nil) => false There are two defs for nil? in Ruby. The one in Kernel is hard coded to return false, and one on NilClass hard coded to return true. Remarkably elegant! It removes one form of branching by exploiting method dispatch.

Introducing Gemini 4 Carbon, our latest frontier model. Carbon delivers improved performance across domains — ranking #1# on v5.0 of the @ArtificialAnlys Intelligence Index and sets a new state-of-the-art in cybersecurity and long-horizon capabilities. It’s rolling out starting this week to cyber defenders through our Fairwind Program, with expanded access coming soon 🧵

The core formula for scaling agent autonomy via @_lopopolo: 1️⃣ Build small, deterministic PRs 2️⃣ Use agents to operationalize agents to handle PR review 3️⃣ Stack small changes end-to-end over longer arcs Watch The Agent Factory to learn more →

So in order to get Fiber yields across native frames working (for example, inside Integer#times#) without using ASM and respecting that Artichoke is meant to be embeddable, Ruby frames are actually interpreter heap data; this allows Fiber stack and subsequent locals to be collected like any other heap objects during GC. In Artichoke’s VM, the Ruby stack is just a Vec; Fiber parking splits frames off from that Vec and stashes them; Fiber resumption reattaches them. But Artichoke’s “Ruby semantic layer” (how to do implicit conversions, delegate to blocks, map to specific exceptions, etc) is written in Rust; they are native frames so we can’t do the split off from the VM stack trick. So, like code is free. So using a nightly Rust compiler, we can extract the MIR for the Ruby semantic layer and lower it into Artichoke’s IR and literally execute Rust code as if it were Ruby. Artichoke’s data structures are pure Rust and never call back into Ruby, so once the semantic layer bottoms out at native code, the VM invokes a native Rust routine and we bottom out. Combined with Artichoke’s Ruby semantic layer also providing specialized routines when operands are known or blocks are not passed, this permits the VM to optimize across native calls. 6 * 5 + 4 is able to avoid any intermediate Ruby value boxing and directly do a multiplication and an add (but actually this would just get folded to a constant). Pretty fuckin’ rad. It is as they say, simply a matter of tokens. About 75% of these native Rust routines lower and link today.

so an update on my AI psychosis, in the last 5 days, I've picked up work on @artichokeruby. I have completely removed its mruby backend. At this point I have: * Full lowering from source to AST via Prism * Lowering from AST to a Ruby specific IR * IR optimization passes (dead store elimination, constant folding, guarded specialization for privileged class method dispatch, data structure capacity hints, ivar fast paths, DCE, DBE, basic block and frame elimination) * Several effect analyses in IR passes (tracking privileged class type hinting, identifying noexcept basic blocks, etc) * Code generation with a register based VM * LTO, whole program optimization * Large swaths of the Core classes fully implemented * Heap, GC (Immix), ivar storage, method lookup and caching machinery * CLI, including IR and bytecode dumpers to guide optimization work * A full Rust reimplementation of the Onigmo regex engine and 36 of its encodings * A "ruby semantic layer" that handles callbacks, rooting, invalidation, coercion policy, and recursion independent of any concrete interpreter; because it is generic, there are test harnesses that run it with a randomizing heap and GC after every yield point * A whole swath of data structures representing Ruby Core classes * A parallel impl of rust std and alloc that has zero infallibly allocating pathways * Native implementations of `File`, `IO`, `Dir`, and `Socket` using rustix and windows-sys * support for custom eh personalities and unwinding using C++ exception handling * "ABI skins" to project Artichoke into arbitrary ABIs, partial implementation of MRI ABI which can link the sqlite C extension The whole "Ruby" is generic over core interpreter intrinsics which means everything is replaceable (heap, object model, GC, value repr). The interpreter was also built to be embedded so it is actually a machine that must be polled with an instruction budget to run. The GC also has a configurable work budget. I expect within a day or so I'll be able to run optcarrot correctly and then will set the token machine to optimize. It is currently pretty slow, but that is, as they say, a reward signal. I've identified nearly 400 MRI errata in this process.

You may not like it, but this is what peak performance looks like. This is the "Ruby semantics" layer of Artichoke. A method like `Array#[]=` has a ton of logic in it above jamming the elements into the RArray. Now, all of it is oblivious to the concrete interpreter and this all gets monomorphized away. Differential fuzzing is extremely cheap. This means heap, allocator, the entire VM, GC, object model, backing Hash storage, all of it can be replaced. This was my dream back in 2019 but it is SO tedious to write code like this. Not anymore! Now I can just dream big.

Today at Google Cloud’s Gemini at Work event, we announced Gemini, a new single universal agent for work that has all of your business context and can be used for everything from knowledge work to answering questions, and content creation to coding, all from a single prompt box. It’s built around core architectural principles: ☑️ Unified Agent: Gemini can answer questions, do knowledge work and generate code from a single prompt box. ☑️Access: Gemini is web-based and can be accessed from any device and integrated into third-party applications. It can also operate without a dedicated user interface. ☑️Persistent Execution: It runs in the cloud, which means it maintains a single set of memories, context and one personalization graph no matter where you access it. ☑️Multi-Agent Orchestration: Gemini can create sub-agents to tackle multi-step tasks and can also act as a coworker agent with a defined role and its own dedicated identity ☑️Context: Gemini knows your tools, data, and work history and learns how you work the more you use it. ☑️Model Choice Flexibility: It orchestrates across multiple models to deliver optimal quality and lower your costs.

good prompt for the lorge models > can you find places where we are fighting the frameworks we are using, reinventing things unnecessarily (while still keeping our strict supply chain posture), relying on deprecated behavior, buggy, or needlessly complex? any tests that don't pull their weight which if removed could significantly simplify the code?