{"slug": "bumpalo", "name": "bumpalo", "category": "dev-libs", "category_name": "Libraries and frameworks", "description": "", "recommenders": 4, "commenters": 9, "warners": 2, "score": 2.567, "rising": 2.35, "first": "2025-12-04", "latest": "2026-10-29", "why": "you do not need to sell me on bumpalo, I use it heavily already", "why_is_quote": true, "has_verdict": false, "sentiment": {"recommend": 6, "neutral": 2, "compare": 1, "warn": 2}, "spark": [0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1], "listed": true, "loved": [], "caveat": "", "short_quote": "you do not need to sell me on bumpalo, I use it heavily already", "kind": "", "icon": false, "domain": null, "github_repo": null, "official_url": "https://github.com/fitzgen/bumpalo", "pricing": "", "aliases": ["bumpalo", "Bumpalo"], "verdict": null, "praise": [{"label": "", "summary": "", "quotes": [{"id": 804455008, "item_id": 50278438, "url": "https://news.ycombinator.com/item?id=50278438", "by": "lunar_mycroft", "date": "2026-10-28", "version": null, "stance": "recommend", "quote": "you do not need to sell me on bumpalo, I use it heavily already", "excerpt": "I agree that arenas aren't always the best choice, but I think you're underestimating how often they are. Not only does a lot of software have elements that are well suited to arenas (request handling for web servers, frames for games and UI, etc), but a lot of allocations are for short lived intermediary values anyway (the stack is basically an arena with a bit less flexibility). (Also, you do not need to sell me on", "context": "", "use_case": "arena allocation", "switched_from": "", "story": "Four Months of Zig"}, {"id": 796399120, "item_id": 49774945, "url": "https://news.ycombinator.com/item?id=49774945", "by": "delifue", "date": "2026-09-20", "version": null, "stance": "recommend", "quote": "the dropping plays well with arena as long as you use bumpalo::boxed::Box", "excerpt": "Rust supports arena allocator https://docs.rs/bumpalo/latest/bumpalo/ and the dropping plays well with arena as long as you use bumpalo::boxed::Box", "context": "", "use_case": "arena allocation", "switched_from": "", "story": "What Zig felt like, coming from Rust"}, {"id": 791584928, "item_id": 49474058, "url": "https://news.ycombinator.com/item?id=49474058", "by": "kibwen", "date": "2026-08-28", "version": null, "stance": "recommend", "quote": "Rust supports arenas just fine ( https://crates.io/crates/bumpalo )", "excerpt": "Rust supports arenas just fine ( https://crates.io/crates/bumpalo ), and if you mean the support for using custom allocators in the standard library collections, that's as stable as Zig is.", "context": "", "use_case": "Arena allocation in Rust", "switched_from": "", "story": "Saving 100 terabytes of memory by optimizing 1.1.1.1's DNS cache"}, {"id": 782163872, "item_id": 48885242, "url": "https://news.ycombinator.com/item?id=48885242", "by": "kibwen", "date": "2026-07-12", "version": null, "stance": "recommend", "quote": "it's quite easy to use and fits the borrow checker very well", "excerpt": "There are several libraries for doing arena allocation in Rust, e.g. bumpalo: https://crates.io/crates/bumpalo , see the documentation for examples (it's quite easy to use and fits the borrow checker very well). The comments in here regarding Rust are somewhat misleading; Rust doesn't require unstable/nightly features to do this sort of stuff. What's unstable in Rust right now is a standardized interface for generica", "context": "", "use_case": "arena allocation in Rust", "switched_from": "", "story": "Understanding the Odin Programming Language"}, {"id": 745160736, "item_id": 46572546, "url": "https://news.ycombinator.com/item?id=46572546", "by": "autarch", "date": "2026-01-10", "version": null, "stance": "recommend", "quote": "maybe you wouldn't need to do this sort of thing by hand", "excerpt": "I was wondering about this myself. My guess is no, since AFAIK the only way to do this sort manual memory management is to use unsafe code. But there's also things like the (bumpalo)[https://docs.rs/bumpalo/latest/bumpalo] crate in Rust, so maybe you wouldn't need to do this sort of thing by hand, in which case you're as leak-free as the bumpalo crate.", "context": "", "use_case": "Arena memory allocation", "switched_from": "", "story": "Finding and Fixing Ghostty's Largest Memory Leak"}]}], "caveats": [{"label": "", "summary": "", "quotes": [{"id": 796305440, "item_id": 49769090, "url": "https://news.ycombinator.com/item?id=49769090", "by": "pron", "date": "2026-09-19", "version": null, "stance": "warn", "quote": "Except that's not composable", "excerpt": "> but rust has crates like bumpalo for that purpose. Except that's not composable - not only do you need specialised data structures, but all (transitively) allocating calls need to be specialised. That's the exact same issue we have in C++, and that's the issue Zig seeks to address. BTW, just the other day there was a post here about a language with another interesting approach, but I have yet to give it a close loo", "context": "", "use_case": "", "switched_from": "", "story": "What Zig felt like, coming from Rust"}, {"id": 774191075, "item_id": 48386942, "url": "https://news.ycombinator.com/item?id=48386942", "by": "AlotOfReading", "date": "2026-06-03", "version": null, "stance": "warn", "quote": "Rust allows you to drop in non free-list based allocators and GCs (e.g. Bumpalo), but they're relatively immature.", "excerpt": "LLVM does speculative devirtualization as well these days, though it's not as aggressive as Hotspot. High-performance native code tries to avoid deep dynamic hierarchies anyway, so it's mitigated by cultural practices. GCs are definitely a strong point for Java, but most high-performance code can be rewritten to avoid pummeling memory management. This used to be common for Java in financial applications, not sure if ", "context": "", "use_case": "", "switched_from": "", "story": "Every Byte Matters"}]}], "who": [], "tags": [], "use_cases": ["arena allocation", "arena allocation in rust", "bump allocation in simulation software", "arena memory allocation", "arena allocation for trees"], "compared": [], "makers": [], "threads": [{"url": "https://news.ycombinator.com/item?id=49766637", "title": "What Zig felt like, coming from Rust", "mentions": 2}, {"url": "https://news.ycombinator.com/item?id=46153466", "title": "Thoughts on Go vs. Rust vs. Zig", "mentions": 2}, {"url": "https://news.ycombinator.com/item?id=50278645", "title": "noalloc: Tooling and libraries to enforce zero heap allocations in Golang", "mentions": 1}, {"url": "https://news.ycombinator.com/item?id=50265128", "title": "Four Months of Zig", "mentions": 1}, {"url": "https://news.ycombinator.com/item?id=49468083", "title": "Saving 100 terabytes of memory by optimizing 1.1.1.1's DNS cache", "mentions": 1}, {"url": "https://news.ycombinator.com/item?id=48880499", "title": "Understanding the Odin Programming Language", "mentions": 1}], "sentiment_by_month": {"2025-11": {}, "2025-12": {"recommend": 1, "neutral": 2}, "2026-01": {"recommend": 1}, "2026-02": {}, "2026-03": {}, "2026-04": {}, "2026-05": {}, "2026-06": {"warn": 1}, "2026-07": {"recommend": 1}, "2026-08": {"recommend": 1}, "2026-09": {"warn": 1, "recommend": 1}, "2026-10": {"recommend": 1, "compare": 1}}, "versions": [], "version_unnamed": 0, "family_ref": null, "runs_on": null, "lines": [], "quotes": [{"id": 804705857, "item_id": 50294116, "url": "https://news.ycombinator.com/item?id=50294116", "by": "vatsachak", "date": "2026-10-29", "version": null, "stance": "compare", "quote": "I found that mimalloc does just as good as bumpalo (within 5%)", "excerpt": "I've been writing Rust for a year and change professionally, also as a hobby, and even though I love it, it's really annoying to choose the allocation model and lifetime model at every step. For example, - A field in a struct cannot borrow another field so now you'd have to create two structs. I guess you could write an impl to borrow that field instead of storing the borrow. - In simulation software I wrote I found ", "context": "writes Rust professionally and as a hobby", "use_case": "bump allocation in simulation software", "switched_from": "", "story": "noalloc: Tooling and libraries to enforce zero heap allocations in Golang"}, {"id": 804455008, "item_id": 50278438, "url": "https://news.ycombinator.com/item?id=50278438", "by": "lunar_mycroft", "date": "2026-10-28", "version": null, "stance": "recommend", "quote": "you do not need to sell me on bumpalo, I use it heavily already", "excerpt": "I agree that arenas aren't always the best choice, but I think you're underestimating how often they are. Not only does a lot of software have elements that are well suited to arenas (request handling for web servers, frames for games and UI, etc), but a lot of allocations are for short lived intermediary values anyway (the stack is basically an arena with a bit less flexibility). (Also, you do not need to sell me on", "context": "", "use_case": "arena allocation", "switched_from": "", "story": "Four Months of Zig"}, {"id": 796399120, "item_id": 49774945, "url": "https://news.ycombinator.com/item?id=49774945", "by": "delifue", "date": "2026-09-20", "version": null, "stance": "recommend", "quote": "the dropping plays well with arena as long as you use bumpalo::boxed::Box", "excerpt": "Rust supports arena allocator https://docs.rs/bumpalo/latest/bumpalo/ and the dropping plays well with arena as long as you use bumpalo::boxed::Box", "context": "", "use_case": "arena allocation", "switched_from": "", "story": "What Zig felt like, coming from Rust"}, {"id": 796305440, "item_id": 49769090, "url": "https://news.ycombinator.com/item?id=49769090", "by": "pron", "date": "2026-09-19", "version": null, "stance": "warn", "quote": "Except that's not composable", "excerpt": "> but rust has crates like bumpalo for that purpose. Except that's not composable - not only do you need specialised data structures, but all (transitively) allocating calls need to be specialised. That's the exact same issue we have in C++, and that's the issue Zig seeks to address. BTW, just the other day there was a post here about a language with another interesting approach, but I have yet to give it a close loo", "context": "", "use_case": "", "switched_from": "", "story": "What Zig felt like, coming from Rust"}, {"id": 791584928, "item_id": 49474058, "url": "https://news.ycombinator.com/item?id=49474058", "by": "kibwen", "date": "2026-08-28", "version": null, "stance": "recommend", "quote": "Rust supports arenas just fine ( https://crates.io/crates/bumpalo )", "excerpt": "Rust supports arenas just fine ( https://crates.io/crates/bumpalo ), and if you mean the support for using custom allocators in the standard library collections, that's as stable as Zig is.", "context": "", "use_case": "Arena allocation in Rust", "switched_from": "", "story": "Saving 100 terabytes of memory by optimizing 1.1.1.1's DNS cache"}, {"id": 782163872, "item_id": 48885242, "url": "https://news.ycombinator.com/item?id=48885242", "by": "kibwen", "date": "2026-07-12", "version": null, "stance": "recommend", "quote": "it's quite easy to use and fits the borrow checker very well", "excerpt": "There are several libraries for doing arena allocation in Rust, e.g. bumpalo: https://crates.io/crates/bumpalo , see the documentation for examples (it's quite easy to use and fits the borrow checker very well). The comments in here regarding Rust are somewhat misleading; Rust doesn't require unstable/nightly features to do this sort of stuff. What's unstable in Rust right now is a standardized interface for generica", "context": "", "use_case": "arena allocation in Rust", "switched_from": "", "story": "Understanding the Odin Programming Language"}, {"id": 774191075, "item_id": 48386942, "url": "https://news.ycombinator.com/item?id=48386942", "by": "AlotOfReading", "date": "2026-06-03", "version": null, "stance": "warn", "quote": "Rust allows you to drop in non free-list based allocators and GCs (e.g. Bumpalo), but they're relatively immature.", "excerpt": "LLVM does speculative devirtualization as well these days, though it's not as aggressive as Hotspot. High-performance native code tries to avoid deep dynamic hierarchies anyway, so it's mitigated by cultural practices. GCs are definitely a strong point for Java, but most high-performance code can be rewritten to avoid pummeling memory management. This used to be common for Java in financial applications, not sure if ", "context": "", "use_case": "", "switched_from": "", "story": "Every Byte Matters"}, {"id": 745160736, "item_id": 46572546, "url": "https://news.ycombinator.com/item?id=46572546", "by": "autarch", "date": "2026-01-10", "version": null, "stance": "recommend", "quote": "maybe you wouldn't need to do this sort of thing by hand", "excerpt": "I was wondering about this myself. My guess is no, since AFAIK the only way to do this sort manual memory management is to use unsafe code. But there's also things like the (bumpalo)[https://docs.rs/bumpalo/latest/bumpalo] crate in Rust, so maybe you wouldn't need to do this sort of thing by hand, in which case you're as leak-free as the bumpalo crate.", "context": "", "use_case": "Arena memory allocation", "switched_from": "", "story": "Finding and Fixing Ghostty's Largest Memory Leak"}, {"id": 739637696, "item_id": 46227356, "url": "https://news.ycombinator.com/item?id=46227356", "by": "LegionMammal978", "date": "2025-12-10", "version": null, "stance": "neutral", "quote": "the bumpalo crate [0] has two relevant methods", "excerpt": "Yes, or rather, the lifetime of references to the contained objects can be tied to the lifetime of references to the arena. E.g., the bumpalo crate [0] has two relevant methods, Bump::alloc(), which puts a value into the arena and gives you back a reference, and Bump::reset(), which erases everything from the arena. But Bump::reset() takes a &mut self, while Bump::alloc() takes a &self reference and gives back a &mut", "context": "", "use_case": "", "switched_from": "", "story": "Golang's big miss on memory arenas"}, {"id": 738573312, "item_id": 46160832, "url": "https://news.ycombinator.com/item?id=46160832", "by": "nu11ptr", "date": "2025-12-05", "version": null, "stance": "neutral", "quote": "I might reach for Bumpalo to build the tree in a single allocation", "excerpt": "> Go has full automatic memory management and Rust doesn't It doesn't? In Go, I allocate (new/make or implicit), never free. In Rust, I allocate (Box/Arc/Rc/String), never free. I'm not sure I see the difference (other than allocation is always more explicit in Rust, but I don't see that as a downside). Or are you just talking about how Go is 100% implicit on stack vs heap allocation? > Sometimes being able to make t", "context": "", "use_case": "arena allocation for trees", "switched_from": "", "story": "Thoughts on Go vs. Rust vs. Zig"}, {"id": 738495936, "item_id": 46155996, "url": "https://news.ycombinator.com/item?id=46155996", "by": "kibwen", "date": "2025-12-04", "version": null, "stance": "recommend", "quote": "Though I'd still reach for something like Bumpalo", "excerpt": "> You don't need an allocator library at all for this easy case, that's more valuable when the shape of allocations is in fact dynamic. Though I'd still reach for something like Bumpalo ( https://crates.io/crates/bumpalo ) unless I had good reason to avoid it.", "context": "", "use_case": "Arena allocation", "switched_from": "", "story": "Thoughts on Go vs. Rust vs. Zig"}]}