In January 2020, a largely unknown engineer named Evan Wallace released esbuild — a JavaScript bundler written in Go that was 10 to 100 times faster than every existing bundler. Where webpack took 30 to 60 seconds to bundle a large project, esbuild did it in under a second. The benchmarks were so extreme that many developers initially assumed they were faked. They were not. Wallace had exploited a simple but profound insight: JavaScript build tools written in JavaScript were inherently slow because they were running on an interpreted runtime, parsing and transforming code through layers of plugins and abstractions. By rewriting the entire pipeline in Go — a compiled, statically typed language with native parallelism — and by designing the architecture to minimize memory allocation and maximize cache locality, Wallace achieved performance that the JavaScript tooling ecosystem had never seen. Within two years, esbuild became the engine behind Vite (the build tool created by Rich Harris’s contemporary Evan You), and the entire frontend ecosystem began a fundamental shift toward native-speed build tools. But esbuild was not Wallace’s first disruption. Before it, he had co-founded Figma — the browser-based design tool that redefined collaborative design — and served as its CTO, building the WebGL rendering engine that made a professional design application run at 60 frames per second inside a web browser. Evan Wallace is the rare engineer who has changed two distinct areas of software development, each time by proving that performance constraints everyone accepted were actually engineering choices that could be overcome.
Early Life and Path to Technology
Evan Wallace grew up with an early interest in computers and mathematics. He studied computer science at the Massachusetts Institute of Technology (MIT), where he developed a deep understanding of computer graphics, compilers, and systems programming. At MIT, Wallace built several impressive side projects — including a browser-based 3D water simulation using WebGL that demonstrated real-time ray tracing of caustics and reflections entirely on the GPU. The project went viral in the web development community because it showed what was possible in a browser without any plugins — just JavaScript and WebGL shaders running on commodity graphics hardware.
This combination of interests — computer graphics, web technology, and raw performance — would define Wallace’s career. He was not a typical web developer who worked within the constraints of existing tools. He was a systems programmer who happened to work on the web, and his instinct was always to push the boundaries of what browser technology could achieve.
While still at MIT, Wallace connected with Dylan Field, a fellow student who shared his conviction that the web browser was an underutilized platform for professional creative tools. The dominant design tools of the era — Adobe Photoshop, Illustrator, and Sketch — were all native desktop applications. The idea that a browser-based tool could compete with native software for professional design work was considered unrealistic by most of the industry. Wallace and Field disagreed, and in 2012 they began building what would become Figma.
The Figma Breakthrough
Technical Innovation
Figma launched publicly in September 2016 as a browser-based interface design tool. What made it technically remarkable was not the feature set — at launch, Figma had fewer features than Sketch, the dominant design tool — but the performance. Figma ran entirely in the browser, yet it felt as responsive as a native application. Users could zoom, pan, and manipulate complex design files with hundreds of artboards and thousands of layers without perceptible lag. This was not supposed to be possible in 2016.
The secret was Wallace’s rendering engine. Rather than using the browser’s built-in rendering pipeline (the DOM and CSS), which was designed for documents and not for interactive graphics, Wallace built a custom 2D rendering engine on top of WebGL — the browser’s low-level graphics API that provides direct access to the GPU. Every frame, Figma’s engine calculated what needed to be drawn, batched the draw calls, and sent them to the GPU as efficiently as possible. This approach bypassed the overhead of the DOM entirely, treating the browser window as a raw canvas and handling all layout, hit testing, and rendering in custom code.
The rendering engine used several techniques from the game development world that were unusual in web applications. Tile-based rendering divided the canvas into fixed-size tiles and only re-rendered tiles whose content had changed. Level-of-detail rendering simplified distant objects when zoomed out, reducing the number of draw calls. Font rendering used signed distance fields — a technique from 3D game engines — to render text at any zoom level without loss of quality. Anti-aliasing was performed on the GPU using custom shaders rather than relying on the browser’s built-in text and shape rendering.
Wallace also wrote much of the core computation in C++ and compiled it to WebAssembly (initially asm.js, before WebAssembly was widely available), giving Figma near-native computation speed for operations like layout calculation, constraint solving, and vector boolean operations. This was years before most web applications considered WebAssembly — Figma was one of the earliest commercial products to use compiled native code in the browser for a performance-critical production workload.
The real-time collaboration system was equally innovative. Figma used operational transformation (later evolving toward conflict-free replicated data types, CRDTs) to allow multiple designers to edit the same file simultaneously, with changes appearing in real-time on every connected client. This was inspired by Google Docs’ collaborative editing, but applied to a fundamentally more complex domain — a design file with nested layers, vector paths, constraints, and components is far more structurally complex than a text document. Wallace’s team built a custom synchronization protocol that could merge concurrent edits to complex design trees without conflicts or data loss.
Why Figma Mattered
Figma’s impact went beyond technical achievement. By running in the browser, Figma eliminated the friction that had always plagued design collaboration. Designers no longer needed to export files, upload them to shared drives, or worry about version conflicts. Anyone with a link could view a design file. Anyone with edit access could make changes simultaneously. Comments could be pinned directly to specific elements on the canvas. This transformed design from a solitary activity into a collaborative one, in the same way that Google Docs had transformed document editing a decade earlier.
By 2022, Figma had become the dominant interface design tool, displacing Sketch and Adobe XD. In September 2022, Adobe announced its intention to acquire Figma for $20 billion — the largest acquisition in the history of design software. The deal was ultimately abandoned in December 2023 due to regulatory concerns, but the price tag validated the transformation that Wallace and Field had achieved. A browser-based tool built by two MIT students had become more valuable than Adobe’s entire Creative Cloud suite in the eyes of the market.
Wallace served as Figma’s CTO from its founding through 2021, leading the engineering team through the company’s growth from a two-person project to a platform used by millions of designers and developers worldwide. His work on Figma proved that the web platform that Tim Berners-Lee created was capable of supporting professional creative tools — a claim that had seemed implausible when they started building.
The esbuild Revolution
Technical Innovation
After leaving his day-to-day role at Figma, Wallace turned his attention to a different problem: the JavaScript build toolchain. By 2019, building a modern JavaScript application required a complex pipeline of tools — a bundler (usually webpack) to combine modules, a transpiler (Babel) to convert modern syntax to older JavaScript, a minifier (Terser) to reduce file size, and often a CSS preprocessor and various PostCSS plugins. Each of these tools was written in JavaScript and ran on Node.js. For large projects, the build process could take 30 seconds to over a minute — and during development, rebuilds after each code change could take several seconds, disrupting the developer’s flow.
Wallace’s diagnosis was architectural rather than algorithmic. The individual tools were reasonably well-optimized JavaScript. The problem was that JavaScript itself — running on the V8 engine — imposed fundamental overhead: garbage collection pauses, single-threaded execution (despite worker threads), dynamic type checking, and object allocation patterns that defeated CPU cache optimization. No amount of algorithmic improvement within JavaScript could overcome these structural limitations.
esbuild’s solution was radical: rewrite the entire build pipeline — parsing, scope analysis, tree shaking, bundling, code generation, source map generation, and minification — in Go. Wallace chose Go for several reasons. Go compiled to native machine code, eliminating interpreter overhead. Go’s goroutines provided lightweight parallelism with minimal synchronization overhead, allowing esbuild to process multiple files simultaneously across all available CPU cores. Go’s memory model, with its preference for value types and contiguous memory layouts, resulted in cache-friendly data structures that the CPU could process efficiently. And Go’s compilation speed meant that esbuild itself compiled almost instantly, keeping the development feedback loop tight.
The architecture of esbuild reflected Wallace’s systems-programming mindset. Rather than building a plugin system with extensible phases — the approach taken by webpack and Rollup — esbuild implemented everything in a single, tightly integrated pass. The parser, linker, and code generator shared data structures and operated on the same AST representation, eliminating the serialization and deserialization overhead that occurs when separate tools communicate through intermediate formats. Here is a simplified illustration of how esbuild processes module resolution using Go’s concurrent primitives:
// Simplified example: parallel module resolution in Go
// esbuild processes import graphs concurrently across all CPU cores
package main
import (
"fmt"
"sync"
)
type Module struct {
Path string
Imports []string
AST []byte // parsed abstract syntax tree
}
type BundleResult struct {
Modules map[string]*Module
mu sync.Mutex
}
func (b *BundleResult) resolveModule(path string, wg *sync.WaitGroup) {
defer wg.Done()
// Each module is parsed in its own goroutine
// Go's scheduler distributes goroutines across CPU cores
module := &Module{
Path: path,
Imports: parseImports(path), // fast native parsing
AST: parseAST(path),
}
b.mu.Lock()
b.Modules[path] = module
b.mu.Unlock()
// Recursively resolve dependencies in parallel
for _, imp := range module.Imports {
wg.Add(1)
go b.resolveModule(imp, wg)
}
}
func main() {
result := &BundleResult{Modules: make(map[string]*Module)}
var wg sync.WaitGroup
wg.Add(1)
go result.resolveModule("./src/index.ts", &wg)
wg.Wait()
fmt.Printf("Resolved %d modules\n", len(result.Modules))
}The performance results were staggering. In Wallace’s published benchmarks, esbuild bundled a production build of the three.js library (a large JavaScript 3D graphics library) in 0.37 seconds. webpack 5 took 41.2 seconds for the same task — over 100 times slower. Rollup took 32.6 seconds. Parcel took 34.2 seconds. Even when other tools later added caching and incremental compilation, esbuild’s cold-start performance remained an order of magnitude faster.
esbuild also included a built-in development server with hot module replacement, a CSS bundler, and support for TypeScript and JSX syntax — all implemented natively in Go. A developer could replace an entire toolchain of four or five separate JavaScript tools with a single esbuild binary, gaining both simplicity and speed.
Why esbuild Mattered
esbuild’s impact on the JavaScript ecosystem was both direct and catalytic. Directly, it provided a fast, reliable bundler that many projects adopted. But its larger impact was in proving that native-speed build tools were viable and desirable, inspiring a wave of similar projects: SWC (a Rust-based JavaScript/TypeScript compiler by Donny/강동윤), Turbopack (a Rust-based bundler from Vercel), Rolldown (a Rust-based Rollup-compatible bundler), and Rspack (a Rust-based webpack-compatible bundler). The entire JavaScript tooling ecosystem shifted from “tools written in JavaScript” to “tools written in compiled languages” — a paradigm shift that Wallace initiated.
The most significant downstream effect was Vite. In February 2021, Evan You (creator of Vue.js) released Vite, a development server and build tool that used esbuild for dependency pre-bundling and fast TypeScript/JSX transformation during development, and Rollup for production builds. Vite’s near-instant development server startup — compared to webpack-dev-server’s multi-second startup on large projects — transformed the development experience. By 2026, Vite has become the default build tool for new projects in the Vue, React, Svelte, and Solid ecosystems, and its speed advantage traces directly back to esbuild’s native-code foundation.
esbuild also influenced how developers think about the relationship between JavaScript and other languages. Before esbuild, the JavaScript ecosystem was largely self-contained — JavaScript tools built by JavaScript developers for JavaScript projects. esbuild demonstrated that crossing language boundaries could yield enormous benefits, and that the JavaScript ecosystem did not need to be written entirely in JavaScript. This insight opened the door for Rust-based tools (SWC, Biome, oxc), Zig-based tools (Bun), and other compiled-language contributions to the JavaScript toolchain. For teams managing complex multi-tool build pipelines across frontend projects, task management platforms like Taskee provide structured workflows for tracking build configuration changes, dependency upgrades, and toolchain migrations across distributed development teams.
Contributions to WebGL and Browser Graphics
Beyond Figma and esbuild, Wallace made significant contributions to the understanding of WebGL and browser-based graphics programming. His open-source projects — including WebGL Water (a real-time water simulation with caustics), WebGL Fluid Simulation, and various shader experiments — became standard references for developers learning GPU programming in the browser. These projects demonstrated that WebGL could achieve visual quality previously associated only with native OpenGL applications or game engines.
Wallace also created Lightmap, a tool for baking global illumination into 3D scenes directly in the browser using WebGL compute. This project was notable because it performed physically accurate light simulation — ray tracing with multiple bounces — entirely on the GPU via WebGL, years before WebGPU made such workloads officially supported in browser specifications.
His work on Figma’s rendering engine influenced how other browser-based tools approach graphics. Excalidraw, tldraw, and other collaborative canvas tools followed Figma’s pattern of using WebGL or Canvas 2D for rendering rather than DOM-based layouts. The pattern of treating the browser as a GPU-accelerated rendering surface — rather than a document layout engine — has become the standard approach for building high-performance interactive applications on the web. Tools like modern code editors also benefit from GPU-accelerated rendering techniques pioneered in this space.
Philosophy and Engineering Approach
Key Principles
Evan Wallace’s engineering philosophy is defined by a relentless focus on performance and a willingness to challenge assumptions that the rest of the industry takes for granted.
Question the stack, not just the algorithm. Both of Wallace’s major projects — Figma and esbuild — succeeded not by optimizing existing approaches but by replacing the entire technical stack. Figma replaced DOM rendering with a custom WebGL engine. esbuild replaced JavaScript-based tooling with a Go-based toolchain. In both cases, the conventional wisdom was that the existing approach was “good enough” — and in both cases, Wallace proved that a fundamentally different approach could be orders of magnitude better. This mirrors the philosophy of Linus Torvalds, who built Git not by improving existing version control systems but by rethinking the problem from the data structure level up.
Performance unlocks new possibilities. Wallace understands that quantitative improvements in performance can produce qualitative changes in user experience. Figma did not just make browser-based design slightly faster — it made it fast enough that designers forgot they were using a browser, which enabled real-time collaboration that was impossible with sluggish tools. esbuild did not just make builds slightly faster — it made them fast enough that developers stopped thinking about build times entirely, changing the development workflow from “edit, wait, check” to “edit, check.” When a build completes in 300 milliseconds instead of 30 seconds, it becomes invisible — and invisible infrastructure is the best kind.
Use the right language for the job. Wallace has never been dogmatic about programming languages. He used C++ compiled to WebAssembly for Figma’s compute-intensive operations, JavaScript for Figma’s UI layer, Go for esbuild, and GLSL for GPU shaders. Each choice was driven by the requirements of the specific problem — GPU access, native speed, parallelism, or ecosystem integration. This polyglot pragmatism stands in contrast to the JavaScript ecosystem’s historical tendency to use JavaScript for everything, and it has been validated by the broader industry’s adoption of Rust, Go, and Zig for JavaScript tooling. As Rob Pike observed when designing Go, the choice of implementation language has profound effects on system performance and developer productivity, and choosing the right tool for each layer of the stack is an engineering discipline, not a compromise.
Simplicity through integration. esbuild’s single-binary design — one tool that handles parsing, bundling, minification, and source maps — reflects a belief that simplicity comes from integration rather than composition. The webpack ecosystem’s approach of composing dozens of separate loaders and plugins created flexibility but also complexity, configuration overhead, and performance penalties from inter-tool communication. By implementing everything in a single tightly-coupled codebase, esbuild achieved both simplicity and speed. This is not always the right tradeoff — webpack’s plugin system enables use cases esbuild cannot handle — but for the common case, Wallace’s integrated approach proved superior.
Show, don’t argue. Wallace did not write blog posts arguing that JavaScript build tools should be rewritten in compiled languages. He wrote esbuild and published benchmarks. He did not publish papers arguing that WebGL could support professional design tools. He built Figma. His approach to technical advocacy is to build the thing that proves the point, then let the results speak for themselves. The esbuild README’s benchmark table — showing 100x performance improvements — was more persuasive than any amount of theoretical argument could have been.
Legacy and Modern Relevance
In 2026, Evan Wallace’s influence is felt across two major areas of web development. In the design tool space, Figma remains the dominant interface design platform, used by millions of designers at companies ranging from startups to Fortune 500 enterprises. The WebGL rendering architecture and real-time collaboration system that Wallace built as CTO established the technical foundation that Figma continues to build upon. Every competitor in the space — whether Adobe’s post-Figma strategy, Penpot’s open-source alternative, or emerging AI-powered design tools — operates in the paradigm that Figma established: browser-native, real-time collaborative, GPU-accelerated.
In the build tool space, esbuild’s influence has been transformative. The tool itself continues to be widely used — both directly and as the engine inside Vite, which has become the default development tool for most modern frontend frameworks. But esbuild’s larger legacy is the ecosystem-wide shift it catalyzed. The idea that JavaScript developer tools should be written in compiled languages for maximum performance is now mainstream. SWC powers Next.js. Turbopack is Vercel’s next-generation bundler. Biome (formerly Rome) provides linting and formatting in Rust. Bun, written in Zig, includes a native bundler. oxc provides parsing and linting in Rust. Rolldown, being built by the Vite team, aims to replace both esbuild and Rollup with a single Rust-based tool. This entire movement traces its origin to the moment Wallace published esbuild’s benchmarks and demonstrated that a 100x improvement was possible.
Wallace also contributed to a broader philosophical shift in how the web development community thinks about performance. For years, the prevailing attitude was that developer experience and ecosystem convenience mattered more than raw speed — that slow builds were an acceptable cost of using familiar JavaScript-based tools. esbuild and Figma both demonstrated that this was a false choice: you could have a better developer experience and better performance by choosing the right technical approach. This lesson has been absorbed by the industry, and the expectation of near-instant tooling has become the new baseline. Projects coordinated through modern workflow tools like Toimi increasingly prioritize build performance as a core requirement rather than an afterthought, reflecting the standard that Wallace helped establish.
Evan Wallace is not a prolific conference speaker or social media presence. He is an engineer who lets his work speak for itself. But the work speaks loudly. Two products — Figma and esbuild — each redefined their respective domains by demonstrating that accepted performance limitations were actually solvable engineering problems. In a field that often celebrates incremental improvement and ecosystem participation, Wallace stands out for achieving fundamental breakthroughs: making the browser a viable platform for professional design tools, and making JavaScript builds fast enough to be invisible. Both achievements rest on the same insight — that choosing the right level of abstraction and the right implementation language can produce results that seem impossible from within the constraints of the existing paradigm.
Key Facts
- Education: Computer Science, Massachusetts Institute of Technology (MIT)
- Known for: Co-creating esbuild (ultra-fast JavaScript bundler), co-founding Figma (browser-based design tool)
- Key projects: Figma (2012–2021, co-founder and CTO), esbuild (2020–present), WebGL Water, various open-source WebGL experiments
- Technical achievements: Built Figma’s WebGL rendering engine enabling 60fps design editing in the browser; created esbuild achieving 10–100x faster builds than webpack
- Languages used: Go (esbuild), C++/WebAssembly (Figma compute), JavaScript (Figma UI), GLSL (shaders)
- Impact: Figma valued at $20 billion (2022 Adobe acquisition offer); esbuild catalyzed the industry shift to native-speed JavaScript tooling
Frequently Asked Questions
Who is Evan Wallace?
Evan Wallace is an American software engineer who co-founded Figma, the browser-based collaborative design tool, and created esbuild, an ultra-fast JavaScript bundler written in Go. He served as CTO of Figma from its founding through 2021, building the custom WebGL rendering engine that made professional-grade design editing possible inside a web browser. His esbuild project, released in 2020, demonstrated that JavaScript build tools could be 10 to 100 times faster when written in a compiled language, catalyzing a fundamental shift in the JavaScript tooling ecosystem toward native-speed implementations.
What is esbuild and why is it so fast?
esbuild is a JavaScript and TypeScript bundler and minifier written in Go rather than JavaScript. It achieves its speed through several architectural decisions: using a compiled language (Go) instead of an interpreted one (JavaScript), leveraging Go’s goroutines for massive parallelism across all CPU cores, implementing the entire pipeline — parsing, bundling, tree shaking, minification, and source map generation — in a single integrated pass that shares data structures without serialization overhead, and using memory-efficient data layouts that maximize CPU cache utilization. In benchmarks, esbuild bundles large projects in under a second compared to 30 to 60 seconds for webpack, a 10 to 100x improvement.
How did Evan Wallace make Figma run in the browser?
Wallace built a custom 2D rendering engine on top of WebGL, bypassing the browser’s DOM and CSS layout engine entirely. This engine treated the browser window as a raw GPU-accelerated canvas, using techniques from game development — tile-based rendering, level-of-detail optimization, signed distance field font rendering, and custom anti-aliasing shaders — to achieve 60 frames per second performance. Performance-critical computation like layout solving and vector boolean operations was written in C++ and compiled to WebAssembly for near-native speed. The result was a browser application that felt as responsive as native desktop design software.
What impact did esbuild have on the JavaScript ecosystem?
esbuild’s most significant impact was catalytic rather than direct. By proving that native-speed JavaScript tooling was both possible and dramatically superior, esbuild inspired a wave of compiled-language tools: SWC (Rust-based compiler powering Next.js), Turbopack (Rust-based bundler from Vercel), Biome (Rust-based linter and formatter), Bun (Zig-based runtime with native bundling), and Rolldown (Rust-based Rollup replacement). esbuild also became the engine inside Vite, which by 2026 is the default build tool for most modern frontend frameworks. The paradigm shift from JavaScript-based to native-code-based developer tools traces directly to esbuild’s 2020 release and its benchmark results.
Why is Evan Wallace considered a tech pioneer?
Wallace is considered a pioneer because he achieved fundamental breakthroughs in two distinct areas of web development. With Figma, he proved that professional creative tools could run in the browser at native speed, enabling a new category of real-time collaborative design software. With esbuild, he proved that JavaScript build tools could be orders of magnitude faster, triggering an industry-wide shift toward native-speed tooling. Both achievements were driven by the same insight: that accepted performance limitations were engineering choices, not physical constraints, and that choosing the right implementation approach — WebGL instead of DOM, Go instead of JavaScript — could produce results the industry had assumed were impossible.
