Praveen retweeted
The first independent benchmark featuring Goose is out, making it 42% faster than the next fastest languages (C and Rust) across 50 real world inspired tasks: kostya.github.io/LangArena/#…
Praveen retweeted
Goose leads the HttpArena benchmarks in speed and memory efficiency, thanks to @KaitKasak 's new Plod web framework: http-arena.com/#scope=h2&mem…
Praveen retweeted
Goose: my latest programming language. Safer, faster and less memory than Rust/C++ for algorithms where tightly packed, flat data structures matter.
It can represent more kinds of data structures as flat, pointer-free bytes than any language I know.
github.com/aardappel/goose
1/
Praveen retweeted
I always thought it was a shame that modest default stack setups made alloca() a generally-frowned-upon technique in C/C++. With 64 bit architectures, give every stack a virtual address space equal to the physical memory by default!
You can do a surprisingly good job of memory management with just the stack, and I contend that it has both correctness and performance advantages.
Allocations are a trivial pointer adjustment, and frees are literally free. Keeping everything linearly packed is friendlier for all layers of the cache hierarchy, and it makes keeping everything in huge / gigantic pages easy.
Leaving temporary intermediate blocks on the stack can seem wasteful, but unless you are dealing with algorithms that make > O(n) temporary allocations, it is usually not a big deal.
Static analysis can check if you store a stack pointer into a structure deeper in the stack, which is a use-after-free, and then memory management correctness is guaranteed.
The discipline of caller-allocates-return is awkward in some dynamic cases. It would take a change in low level calling conventions, but you could plausibly have functions that return with the stack extended from where it was when they were called. I’m not holding my breath for that.
It isn’t obvious if having AI coding agents makes discussions of software architecture more or less important!
Praveen retweeted
I just made a programming language doing exactly this. As many address-space-reserved huge stacks as the program statically needs, with bump alloc, stable pointers, all compile time safe and yet way faster than what you can do in C++/Rust: github.com/aardappel/goose
Praveen retweeted
Quayside Vantage - Jim Edwards
Original painting, acrylic on board, 50x50cm (image size), oak framed.
jimedwardspaintings.com/stor…
Praveen retweeted
I wanted to show how janky the AI slop is of the FilmCraft software.
I wanted to set the stage for how bad it is, and how little care there has actually been in implementing this tool, and most definitely the entire Craft suite too.
It's all AI slop that does not even work.
Praveen retweeted
Order of the Sinking Star has reached Overwhelmingly Positive reviews on Steam. I am glad y'all are enjoying the game!
Praveen retweeted
After TEN LONG YEARS, Order of the Sinking Star is out Now! On Switch 2, PS5, and ... it's at the top of Popular New Releases on Steam, already!
Thank you everyone for your support during this long, long, long, long, long development!
Praveen retweeted
From Go to Rust.
TiDB rewrite: 1M+ lines, with nearly all TiKV-backed end-to-end tests passing.
Still experimental. More tests and performance validation before a release.
I used to hear “let’s rewrite it” and panic.
Now I’m on board. 😂
Praveen retweeted
Introducing Atlas:
The world's first multimodal world model that generates image and video frames with pixel-perfect camera control and reconstructs them in 3D.
Model the world, move the camera, and simulate space & time.
Praveen retweeted
I want to share how I have developed celld - because it's a bit different and it's working well for me. You might have noticed that the github.com/denoland/celld repo is pretty bare - this is because it's an export of a much larger private repo: denoland/celld.dev
This larger repo contains: an llm-wiki with an enormous amount of design docs, a large test suite, a spec written in TLA+, the code for the website, scripts for spinning up fleets of celld instances on various clouds and running tests against them, and a speculative centralized managed control plane that I might someday release as a commercial product.
My llm-wiki is modified to fit my workflow - diff here gist.github.com/ry/c56dfa7b1…
I find llm-wiki extremely useful for gathering context. Reviewing wiki/design/ is a primary development activity.
celld is open source, but the development happens in private. The test suite and design docs are private. Why do this? First of all, I don't need the public following my every commit - it's oversharing. Secondly, in the age of coding agents, I don't really need external contributors. I'll always appreciate a patch, but most properly reported issues are one-shottable solutions. Third, it's just a bit of IP that might be valuable someday.
I do a lot of experiments with celld on Vultr with a VPC. I'll spin up between 2 and 10 VMs at a time, run some experiment, and usually try to tell some story via a chart of some sort (one below).
My own coding agent setup is ssh/tmux to mac mini, with various codex and claude sessions running. I don't use an enormous number - something like 2-4 at a time. (Why a mac mini? idk someone just gave me it)
Praveen retweeted
Maybe our most frequently asked question
What is Oxide's thinking around GPUs?
FAQ Friday #56
Praveen retweeted
A weird experiment I've been trying the last few weeks is having Claude take over day-to-day maintenance of our apps. Seeing early signs of life that this might be possible.
The setup is straightforward: we have a Slack channel called proj-claude-maintains-apps. In it, Claude Tag runs a bunch of daily routines across iOS, Android, Desktop, web, CLI, and Agent SDK:
- Crash fuzzer: open the app in a simulator and tap around to find ways to crash it, then root cause and fix the crashes
- Dup unifier: scans the codebase for similar-yet-slightly-divergent abstractions, and puts up PRs to unify them
- Dead-code remover: removes statically unreachable code, and adds logging to suspected dead code to check if it's really dead and if so, remove it the next day
- Abstraction police: fixes leaky abstractions
- a bunch more..
Results have been surprisingly positive. Over the last few weeks, these routines have opened 388 PRs across our repos, 180 of which we merged after Claude Code Review + human review. We're now thinking about how to streamline this to make merging these kinds of mechanical changes easier.
Claude generally gets these PRs right on the first shot, and if it doesn't, we ask Claude to tune its routines so it's better the next day. Sometimes it takes a few days of tuning.
To try a similar workflow, ask Claude Code or Tag, or create some routines directly at claude.ai/code/routines. A few of the actual prompts I used below.
Has anyone experimented with similar workflows?
Praveen retweeted
Today we’re introducing Delta. Delta is a multiplayer environment for coding with agents and reviewing what they build, powered by DeltaDB.
The first invites to our private beta are going out now.
zed.dev/blog/introducing-del…
Praveen retweeted
New blog post alert! 🦆 🦆 ⚡
` Asynchronous I/O in DuckDB: Work, Thread, Work `
by @holanda_pe
It doesn't matter how fast query operators are in a database system if we can't pull in the data quickly.
For most of DuckDB's history, however, this problem was largely avoided by pruning data early. By pushing down filters and projections, we could ensure that we only read what we actually needed.
This worked particularly well because DuckDB primarily ran locally, with its main use case being as a quick-draw database engine for querying data directly from your machine's SSD. But, as usual, things changed.
Starting with DuckDB v2.0 – scheduled for fall 2026 – DuckDB will support asynchronous reads of Parquet and CSV files. This significantly speeds up queries when synchronous I/O does not saturate the available bandwidth, as is typical in EC2/S3 compute-storage setups.
Read the rest here: duckdb.org/2026/07/31/asynch…
#DuckDB
Praveen retweeted
Time series workloads rarely stay simple. Fleets grow, schemas get wider and sparser, query patterns shift, and the database needs to stay fast under heavier load.
#InfluxDB 3.11 is built for that reality, with a significant performance upgrade for demanding time series workloads:
• Up to 4x faster for highly selective, single-series queries
• Support for wide and ultra-sparse schemas
• More predictable performance under heavy ingest and compaction
• New Enterprise capabilities for backup and restore, bulk data import, and data management
• The Explorer UI built directly into InfluxDB 3 Core and Enterprise
The result: faster, more predictable performance as time series workloads grow in scale and complexity.
See what’s new in InfluxDB 3.11: bit.ly/4x9gM2H
ALT Dark blue graphic featuring text that highlights "InfluxDB 3.11" by InfluxData. It states a significant performance upgrade for complex time series workloads. Fade-in effect on "3.11".