Electronic Arts Standard Template Library
2 points · Open discussionelectronicarts
EASTL
C++2016–2025
electronicarts / EASTL
EASTL
EASTL stands for Electronic Arts Standard Template Library. It is an extensive and robust implementation that has an emphasis on high performance.
32Distinct people
34Mentions
0Explicit recommenders
9.4KGitHub stars
What to know before exploring
What it is
EASTL stands for Electronic Arts Standard Template Library. It is an extensive and robust implementation that has an emphasis on high performance.
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 5:04:57 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year34 dated mentions
Observed mentions: 2016-02-09 22:24:58 UTC to 2025-04-18 20:26:27 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 8 | 5 | 3 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 6 | 1 | 5 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 3 | 1 | 2 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 2 | 1 | 1 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
EA Standard Template Library
EASTL stands for Electronic Arts Standard Template Library. It is a C++ template library of containers, algorithms, and iterators useful for runtime and tool development across multiple platforms. It is a fairly extensive and robust implementation of such a library and has an emphasis on high performance above all other considerations.
Usage
If you are familiar with the C++ STL or have worked with other templated container/algorithm libraries, you probably don't need to read this. If you have no familiarity with C++ templates at all, then you probably will need more than this document to get you up to speed. In this case, you need to understand that templates, when used properly, are powerful vehicles for the ease of creation of optimized C++ code. A description of C++ templates is outside the scope of this documentation, but there is plenty of such documentation on the Internet.
EASTL is suitable for any tools and shipping applications where the functionality of EASTL is useful. Modern compilers are capable of producing good code with templates and many people are using them in both current generation and future generation applications on multiple platforms from embedded systems to servers and mainframes.
Package Managers
You can download and install EASTL using the Conan package manager:
conan install eastl/3.15.00@
The EASTL package in conan is kept up to date by Conan team members and community contributors. If the version is out-of-date, please create an issue or pull request on the Conan Center Index repository.
You can download and install EASTL using the vcpkg dependency manager:
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
vcpkg install eastl
The EASTL port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please create an issue or pull request on the vcpkg repository.
Documentation
Please see EASTL Introduction.
Compiling sources
Please see CONTRIBUTING.md for details on compiling and testing the source.
Credits And Maintainers
EASTL was created by Paul Pedriana and he maintained the project for roughly 10 years.
EASTL was subsequently maintained by Roberto Parolin for more than 8 years.
He was the driver and proponent for getting EASTL opensourced.
Rob was a mentor to all members of the team and taught us everything we ever wanted to know about C++ spookyness.
After Rob, maintenance of EASTL passed to Max Winkler for roughly a year, then to Liam Mitchell for about another year.
The current maintainers (since circa 2022) are Galo Rojo and Jonathan Hopkins.
Significant EASTL contributions were made by (in alphabetical order):
Avery Lee
Claire Andrews
Galo Rojo
Jonathan Hopkins
JP Flouret
Liam Mitchell
Matt Newport
Max Winkler
Paul Pedriana
Roberto Parolin
Simon Everett
Contributors
Projects And Products Using EASTL
Frostbite - Electronic Arts - [https://www.ea.com/frostbite]
License
Modified BSD License (3-Clause BSD license) see the file LICENSE in the project root.
Read the full README on GitHubWhat Hacker News says
34 sourceshttps://github.com/electronicarts/EASTL
Is pretty good for games.
In Writing your own C++ standard library from scratchThis meme is based on a premise that copying others is bad. But I would argue the opposite: why keep reinventing what already exists?
Take software engineers, for example. Most spend their entire lives rewriting code that's already been written at many companies simply because sharing is verboten. They might go their entire lives redoing what's already been done for a revolving door of bosses, without ever creating something truly new. The scale of wasted potential is stupendous.
If we all agreed on a mindset of more sharing and copying, those engineers could focus their efforts on real innovation and build the future. And there are hundreds of thousands if not millions of them.
This is not a radical new idea. This was the mindset many software engineers had in the gaming industry (my industry) in the 90s and 00s. Carmack famously release
Read the rest
d his code under what you might call a "have fun" license[0]. Around late 90s it was re-licensed under GPL to promote open-source/hacker development. This is why DOOM (and Quake) has been hacked to run on everything and used as a base for many games and game engines – real innovation instead of reinventing the same game.
Today game companies guard their code fiercely. I'm not only talking about serious trade secrets, but most frivolous basic libraries, like they would go bankrupt if they shared. Well, guess what, EA shares EASTL[1] and that didn't make them any less dominant in games. Source Engine is also available under a fairly permissive license, as is Unreal Engine's source code. What's the common denominator? They both were written by people very closely aligned with Carmack's hacker culture. Source was born out of Quake, for example.
The hubris of this closed-off approach is evident when new tech like Copilot arrives. Many tech companies panic about it "using their code" when in reality, that code already exists in numerous open-source libs. And Copilot can write 80% of what a mid level engineer writes in games anyways. Even for a principal/fellow level engineer, it is helpful in boilerplate. You can't escape the absurdity of rewriting what's already been written.
How many ways can you allocate memory for a dynamically allocated array anyways? How many ways to implement the PID controller to steer an AI car in games? How many ways to do occlusion culling in graphics? A few, but not many. Yet every company guards it like it's their own secret sauce.
So yeah, it would be pretty mature to revisit our values and go back to what worked in computing.
[0] https://github.com/id-Software/DOOM?tab=readme-ov-file – still has the "have fun" readme.
[1] https://github.com/electronicarts/EASTL
EA also released their own implementation of the C++ standard library. As a games company, this makes sense as performance can become a bottleneck much faster in games than in a lot of other applications.
https://github.com/electronicarts/EASTL
In The "Best" Library: A C++ STL ReplacementNote that EASTL (an alternative STL used in game development) does std::string the "Clang way": https://github.com/electronicarts/EASTL/blob/master/include/...
In An informal comparison of the three major implementations of std:string> you can still use it with smart pointers provided by any other library
Is the point of having a kitchen-sink library like this not that you dont have to reach for a 3rdparty library for things that you need 'all the time'?
Certainly, not everyone needs it.
...but, not everyone needs threads either. Not everyone needs an http server; and yet, if you have an application framework that provides them, when you do need them, it saves you reaching for yet-another-dependency.
Was that not the point from the beginning?
unique_ptr is a fundamental primitive for many, as you see from some other frameworks (1), and implementation is not always either a) trivial, or b) as simple as 'just use std::unique_ptr'.
This does seem like a very opinionated decision with reasonably unclear justification; perfectly fair, you're certainly not beholden to anyon
Read the rest
e to implement features just because they want you to, but I think it's difficult to argue there's not concrete use for something like this, in a way that aligns with the project principals.
I would go so far as to argue that:
> Do not allocate many tiny objects with their own lifetime (and *probably unclear or shared ownership*)
Is hostile to not having a unique pointer.
[1] - eg. https://github.com/EpicGames/UnrealEngine/blob/release/Engin..., https://github.com/electronicarts/EASTL/blob/master/include/...
EA Standard Template Library Design
2 points · Open discussionHistorically, in high-performance resource-constrained applications (eg: console video games), developers would use a "stripped down" version of C++ (eg: no RAII, no exceptions), which often included avoiding STL. It's less true these days, but still somewhat. In truth, STL will never be fully catering to these uses; that's not its goal.
One reason STL was avoided is that control over memory allocation was quite poor. std::allocator was somewhat conceptually broken for a long time, only recently remedied in C++14 and 17. So, there's still about 20 years of code out there from the days of old bad C++ (:
Another reason is that early STL implementations were poor, and not well-suited to high-performance use cases. Again, this has gotten better (some), but the legacy lives on.
Here's a good one to read: https://github.com/electronicarts/EASTL
Read the rest
/blob/master/doc/Desi...
So, if you are designing a library to be used in video games (such as in TFA), and want wide adoption, then avoiding STL, RAII, exceptions is still generally a good idea, IMO.
OK, here is MS STL:
https://github.com/microsoft/STL/blob/main/stl/inc/vector#L1...
Whatever _STL_VERIFY does, pop_back can't throw, as it's marked noexcept.
EA STL: https://github.com/electronicarts/EASTL/blob/master/include/...
Default assertion handler seems to set up a debug break point:
https://github.com/electronicarts/EASTL/blob/29a805e4d83d7dd...
Macro defined somewhere here:
https://github.com/electronicarts/EASTL/blob/76d6842d5d833c0...
Does not seem to throw, but a lot of this is user-configurable.
I'm sure I still didn't cover all implementations. You are free to point out a single one that throws on pop_back. Or just ask ChatGPT which implementation throws.
In Can sanitizers find the two bugs I wrote in C++?I really wish someone takes the work of ditching the STL as a whole and make an unofficial “version 2” of the same standard library. I mean, IO sucks ass, std::string really sucks, containers like unordered_map are really slow (because of the pointer stability requirements), custom allocators are cumbersome, the regex library is a mess, why are string_view and span different things, yada yada. (And darn those long compile times and horrendous debug-mode performance!)
Basically, something like a more updated version of EASTL (https://github.com/electronicarts/EASTL) might be really useful.
In GoSTL: Algorithm and datastructure library for Go similar to C++ STL> Does anyone have direct experience to share?
Used it a few times for some medium-complexity stuff, here’s an open-source example:
https://github.com/Const-me/vis_avs_dx/tree/master/avs_dx/Dx...
Works OK, and indeed faster than VC++ (I was using VS2017 at that time), especially in debug builds.
One interesting feature missing from the standard library is segmented_vector container. https://github.com/electronicarts/EASTL/blob/master/include/...
In EASTL: An Alternative C++ Standard LibraryI don't know where they do their CI/CD now...they seemed to have moved off of travis. But, there's a snapshot of a benchmark from 2019 still here:
https://github.com/electronicarts/EASTL/issues/267
In EASTL: An Alternative C++ Standard LibraryIt's been a long time but from what I remember the selling point for EASTL is the ability to specify your own allocator instance for every container. EA writes portable code across lots of different architectures, many of which share a lot more with embedded systems than with PCs. They have constrained memory or special dedicated memory areas. Also, iirc EA uses tagging allocators extensively letting them trace against memory budgets down to the team level.
Edit: there's an extensive FAQ in the docs folder: https://github.com/electronicarts/EASTL/blob/master/doc/FAQ....
In EASTL: An Alternative C++ Standard LibraryEASTL: An Alternative C++ Standard Library
144 points · Open discussionThis is called arena allocation, and there are many implementations of the concept.
For example, the C++ Protocol Buffers library has an Arena class, which is documented here: https://developers.google.com/protocol-buffers/docs/referenc...
The EA STL has fixed_allocator, which implements a similar concept while exposing more low-level details in the API: https://github.com/electronicarts/EASTL/blob/master/include/...
In Drop millions of allocations by using a linked list (2015)Showing the 15 most recent of 34 sources. Enable JavaScript to search and browse every indexed mention.