Built with Rust: Processing Foundation
How Processing Foundation’s Rust R&D is changing what’s possible in the browser.
Built With Rust is a new series from the Rust Foundation, spotlighting how Rust Commercial Network member organizations and Rust Foundation corporate members are using the Rust programming language to solve real engineering problems in their own words. Each entry will look at the challenge a team faced, what they built in Rust to address it, and what changed as a result.
This installment features the Processing Foundation.
About Processing Foundation
Processing Foundation promotes software learning within the arts, artistic learning within technology, and the diverse communities that make creative coding vibrant and accessible. Its flagship project, Processing, is a flexible software sketchbook and a language that has introduced a generation of artists, designers, and educators to programming.
“The organization envisions a world where artists are empowered to build, remix, and publish open-source creative software, free from proprietary constraints, corporate gatekeeping, and social-economic barriers. The Rust R&D initiative brings us a step closer to the vision.”
– Xin Xin, Co-Executive Director, Processing Foundation
The Challenge: An Aging Graphics API and a Java-Only Ceiling
Processing Java’s rendering engine relied on a deprecated OpenGL graphics API: a dependency that was becoming harder to justify as the ecosystem around it became less supported. Processing Foundation had two goals that OpenGL can’t fulfill: running sketches directly in the browser, and supporting more programming languages beyond Processing Java and p5.js. In addition, the Processing Foundation team wanted to reconnect Processing with the energy of an active, ambitious open-source ecosystem. Rust checked every box.
What They Built: A Shared Rust Core, From Browser to Microcontroller
Processing Project Lead Moon Davé and Bevy contributor Charlotte McElwain dived into the R&D process and built a shared Rust core library that can be dropped into Rust projects directly, linked into other languages via FFI (Foreign Function Interface), or compiled to WASM (WebAssembly) and run in a browser. That core handles window management, user input, rendering, GPU compute and shader pipelines, MIDI, and audio; much of it powered by Bevy, the Rust game engine.
Python support arrived through PyO3, and Rust Embedded is already on the roadmap, meaning the same rendering core that runs in a browser tab could eventually run on a microcontroller.
The Results: 50,000 Moving Objects, One Browser Tab
The improvements weren’t incremental. Instead, they changed what Processing sketches could do:
Flocking simulations that scale: a classic flocking example that currently runs with thousands of 2D boids can now run on the GPU with tens of thousands of 3D boids. With more stabilization, there is room to push towards hundreds of thousands of 3D boids.
Massive-scale rendering: a 3D cube made out of 1 million 3D cubes, all running on the GPU.
Cross-language reach: Processing’s shared Rust core library now powers sketches written in both Java and Python.
“The graphics work happening in Rust is phenomenal, and it’s so easy to get involved and collaborate with all the maintainers of projects we build upon. It didn’t take long to get pulled from theory into demonstrable reality. The deeper I get, the more excited I am with this technical direction.”
– Moon Davé, Processing Project Lead, Processing Foundation
Why It Matters: A Safer, Faster Foundation for Creative Work
For a project whose mission is teaching people to code, raw performance isn’t just an abstract win, it lets an artist go from a sketch idea to tens of thousands of swarming boids without fighting the tools. Rust’s ecosystem, and projects like Bevy and PyO3 built by the community around it, gave the Processing Foundation building blocks flexible enough to serve Java developers, Python developers, and browser-based creative coders alike, all from one core.
Takeaways
Processing Foundation’s rewrite offers a pattern other organizations can learn from, especially those with legacy graphics, rendering, or performance-critical code. Rust doesn’t require throwing out an existing language ecosystem to adopt it. By building a Rust core and exposing it via FFI, WASM, and PyO3, Processing Foundation built capacity to keep Java and Python developers productive while gaining Rust’s performance benefits underneath. It’s a reminder that Rust adoption doesn’t have to be all-or-nothing; a well-designed core can meet developers where they already are.
Processing Foundation’s story is also a real-world validation that the graphics and gamedev tooling maturing in Rust is ready to carry production workloads for organizations well outside the traditional gamedev space. It also shows the compounding value of Rust’s interop story: PyO3 and WASM support meant Processing Foundation didn’t have to choose between reaching Rust natively and reaching the millions of learners already using Processing. For maintainers of crates like Bevy and PyO3, this is a concrete example of their work extending Rust’s reach into new domains (like creative coding and arts education) that they may not have had visibility into otherwise.
Next Steps For Organizations Using Rust
The story above is part of a growing pattern: organizations across industries, from consumer software to creative tools to critical infrastructure, are turning to Rust to build safer, faster, more maintainable systems. Processing Foundation shares its story here as a member of the Rust Commercial Network, the Rust Foundation’s community for organizations building in production with Rust to connect with peers doing the same.
Separately, organizations that want to directly support the maintainers, security audits, and infrastructure the Rust ecosystem depends on can become a Rust Foundation corporate member. RCN participation and corporate membership are independent.
Organizations invested in the health and growth of the Rust programming language are welcome to:
