Click any tag below to further narrow down your results
+ multi agent rl
(1)
+ machine learning
(1)
+ engine design
(1)
+ spacex
(1)
+ raptor 3
(1)
+ ai
(1)
+ exploration strategy
(1)
+ recursive self improvement
(1)
+ dream rsi
(1)
+ biology
(1)
+ simulation
(1)
+ cost per token
(1)
+ reinforcement learning
(1)
+ pufferlib
(1)
+ weakly electric fish
(1)
Links
Handwired converts regular JavaScript control flow (if-else, loops, state) into matrix multiplication and ReLU operations without any training required. The resulting code stays fully differentiable and runs on GPU, enabling use cases like training frozen programs end-to-end or parallelizing sequential JS code.
- Transforms conditional logic into arithmetic using ReLU tricks (e.g., if-else becomes a weighted sum of both branches selected by a binary mask), keeping everything differentiable without training weights
- Collapses all operations into matmul and ReLU primitives, which GPUs can heavily optimize through fusion, sparsity, and reordering techniques
- Enables hybrid workflows: freeze a handwired program and train it alongside a generic neural net, or run sequential JavaScript at GPU-level parallelism (demo processes 100k JSON documents in milliseconds)
Windfoil is a GPU algorithm that handles vector graphics rasterization and differentiable rendering using closed-form winding number calculations for Bézier curves. It runs in WebGPU across browsers and devices, outperforming production renderers like Skia on accuracy while matching the speed of game-focused alternatives.
- Achieves better coverage fidelity than Skia and Slug while maintaining comparable performance to Slug on real-time tasks
- Scales to tens of thousands of shapes at interactive rates, outperforming DiffVG and Bézier Splatting on optimization cost per step
- Works across environments from web browsers to high-resolution print rendering through a single WebGPU implementation
SpaceX cut the Raptor engine from a tangled mess of pipes to a sleek design while gaining 35% more thrust, mostly through changes to the fuel and oxidizer preburner systems and plumbing routing. The article pieces together what likely happened using fan-made schematics and occasional comments from Elon Musk, since SpaceX keeps the actual details classified.
- Raptor 3 delivers 35% more thrust than Raptor 1 despite looking dramatically simpler, suggesting the complexity reduction came from engineering optimization, not compromise.
- The Raptor uses full-flow staged combustion, a notoriously difficult engine architecture that only SpaceX has successfully flown; the earlier versions routed propellant through more convoluted paths that later versions consolidated.
- SpaceX likely reduced engine complexity by combining the two preburners into a single unit and simplifying how fuel flows through the engine structure, based on comparison of fan-made schematics from Raptor 1 and later versions.
This paper presents Dream-RSI, a framework that lets AI agents improve their exploration strategies by learning from past discovery attempts without constantly running expensive new experiments. The system uses historical search data as a simulator to test and refine exploration policies cheaply before deploying them back into the real search space.
- Solves the exploration bottleneck in recursive self-improvement by creating a replay simulator from accumulated discovery history, enabling off-policy feedback without costly online re-evaluation
- Keeps the exploration layer separate from the underlying agent, making strategies explicit and programmable while maintaining compatibility with existing systems
- Demonstrates competitive or better results across algorithm engineering, mathematical optimization, and GPU kernel engineering while substantially cutting discovery costs
@daphnesolves on X
A developer ports the weakly electric fish multi-agent RL simulation from Python to C, using PufferLib, and gets training to about one million steps per second. The result is a strong fish policy trained in roughly 10 seconds, against 6 to 9 hours in the original setup.
- The C port started at about 40,000 steps per second, and switching most doubles to floats added roughly 30% more speed.
- Profiling showed electric-field calculations dominated runtime, so restricting sensor calculations to elements within each organ's short sensory range cut the work sharply.
- Final throughput reached 1.85 million simulation steps per second, against about 4,300 for the reference Python environment, and a 527-run sweep finished in 12 hours.
This article shows that SKILL.md files aren’t static prompts but loader specifications defining what to load, when, and at what cost. It breaks down the three progressive-disclosure levels, explains how architecture—not instruction content—drives context consumption, and highlights common antipatterns that bloat or break skills.
- A 1,200-line monolithic SKILL.md ate 20% of the context window every turn; splitting it into a 180-line driver plus reference files and a script dropped that to 7%.
- SKILL.md files are loader specs with three tiers—frontmatter (~100 tokens, always loaded), body (loads on invocation, keep under 500 lines), and references/scripts (loaded or run only on demand).
- Adding YAML frontmatter to reference files accidentally promotes them to always-loaded skills, cluttering the skill list and causing out-of-context invocations—removing it fixed silent routing errors.
- Context consumption is driven by how content is architected across these layers, not by how much instructional detail is written.
The article argues that enterprises should measure AI infrastructure economics by cost per token rather than raw compute metrics like FLOPS per dollar. It shows how maximizing delivered tokens—through hardware, software and system optimizations—drives down real-world cost and boosts revenue, citing NVIDIA Blackwell’s 35× lower token cost versus Hopper.
- Cost per token (total infra cost ÷ tokens generated), not FLOPS/dollar or GPU hourly rate, is the real measure of AI infrastructure efficiency.
- Blackwell GB300 NVL72 costs almost 2x more per GPU-hour than Hopper H200 ($2.65 vs $1.41), but delivers 65x the tokens/sec per GPU (6,000 vs 90).
- That throughput gap translates to 50x more tokens per megawatt and a 35x lower cost per million tokens ($0.12 vs $4.20).
- Techniques like FP4 precision, speculative decoding, KV-cache offloading, and disaggregated serving are necessary, not optional, to actually achieve these lower token costs.