Pushing UI/UX Design Limits: How Pixso 2.0 Handles 500,000 Layers with Ease

When a fully loaded, complex design still scaled smoothly in the browser, Pixso’s engineers knew their gamble of completely rewriting the rendering engine had paid off — a defining moment for a next-generation UI/UX design tool.

In early 2023, Pixso faced a “sweet problem.” As more and more designers from large tech teams began adopting Pixso as their core UI/UX design tool, the development team received a lot of praise, but also a particular complaint: “We love Pixso’s collaborative experience, but the challenges begin when our design system files exceed 100,000 layers.”

The most dramatic moment occurred one Thursday afternoon. A customer success manager forwarded a message from the head of the design team at a leading internet company, along with a screenshot of a massive design file with over 200,000 layers. “We’d love to switch to Pixso completely,” the person wrote, “but every pan and zoom in this file is a test of patience.”

The Pixso design team knew that if they couldn’t conquer these “monstrous” files, Pixso would never truly become a cornerstone UI/UX design tool for the world’s top design teams. It was time for a complete performance revolution.

Learned from MacBook Pro-Level Stress Testing

In its early days, Pixso’s performance testing focused on typical scenarios. The Pixso development team maintained a standard set of test files, covering everything from mobile pages to simple design systems. This system worked well for a long time.

But the reality is that designers’ creative ambitions and project complexity constantly push the limits of tools. The Pixso team realized they needed to create testing standards that simulated the most extreme scenarios. Thus, Pixso set a new goal: to ensure that Pixso remains elegant and smooth even in scenes as complex as 500,000 layers.

From everyday workflows to extreme performance challenges

The Pixso team internally calls this the “Conquer the MacBook Pro” project, because that’s the machine most of our users use. The goal isn’t just to make Pixso as a ui/ux design tool run incredibly fast on top-tier workstations, but to provide an exceptional user experience on the most common hardware.

Pixso’s Architectural Breakthrough in 2.0

Performance improvements usually come from local optimizations, but this time, the Pixso team knew that minor tweaks wouldn’t cut it; they had to delve into the heart of the engine of a next-gen ui/ux design tool.

The limitations we faced in Pixso 1.0

In Pixso 1.0’s architecture, rendering a complex ui/ux/design scene required traversing the entire layer tree, calculating the positions and styles of all elements. For files with tens or even hundreds of thousands of layers, this process was like a librarian in a vast library, having to search through the entire tree from the beginning every time someone wanted to look up a book. The computational effort grew exponentially, and so did memory usage.

How Pixso 2.0 rebuilt its core performance engine

Pixso 2.0 completely rewrites the core of its rendering engine, introducing a brand-new layered calculation and dynamic rendering mechanism. Think of it as an intelligent, multi-layered indexing system for a vast library.

Space Partitioning Algorithm: The engine now intelligently “knows” which parts of the canvas are visible and which are out of view. It only performs high-precision calculations on elements within and near the current viewport, while lightweight processing is applied to layers outside the viewport. This means that whether your file has 500,000 or 1,000,000 layers, when you focus on a specific area, the engine only needs to process a small portion of them.

Incremental Data Flow: Pixso 2.0 restructures how data flows from the core to the renderer. Instead of triggering a global “big earthquake” for every change, it is transformed into a series of precise, local “micro-updates.” This significantly reduces unnecessary calculations and memory copies.

Memory Pool Management: Pixso 2.0 implements a custom memory allocator specifically for managing graphics objects. This significantly reduces memory fragmentation and overhead caused by the frequent creation and destruction of temporary objects.

Quantifiable Performance Leap Forward: From 19.48s to 6.81s

Theory is all well and good, but reality requires hard data to prove it. In internal benchmark tests, the Pixso team conducted a back-to-back comparison between Pixso 1.0 and 2.0:

When opening a critical test file with 500,000 layers, Pixso 1.0 took an average of 19.48 seconds. Pixso 2.0 reduced this time to 6.81 seconds—an improvement of over 65%.

When processing a large design system file with 200,000 layers, Pixso 2.0’s average memory usage dropped from 3.4GB in Pixso 1.0 to 1.5GB, a 56% reduction.

These figures mean that designers can significantly reduce the wait time between clicking a file and starting to create, and their computers can still run other applications with ease even when working on large projects.

Stories Inside Pixso 2.0: Rendering & Real-Time Collaboration Gains

Story 1: Zooming and panning at massive scale, now butter-smooth

In complex design files, zooming and panning are often the most common performance bottlenecks. Users expect a silky-smooth experience.Using a new spatial partitioning algorithm, we ensure that the engine processes only the minimum necessary data set at any zoom level. More importantly, Pixso 2.0 optimizes the mathematical calculation pipeline for layer transformations (zoom, pan, and rotate). Zooming and panning are now responsive, even in designs with 500,000 layers.

Story 2: Zero frame drops, even in high-pressure collaboration

For Pixso, performance isn’t just about the standalone experience; it’s the cornerstone of collaboration. When multiple designers work simultaneously on the same large file, every edit, both local and remote, must be synchronized and rendered in real time.

Pixso 2.0 restructures the collaborative event processing queue. The new system prioritizes direct actions by the local user (such as dragging a layer) to ensure instant interaction. At the same time, changes from other collaborators are intelligently batched and scheduled to avoid blocking the user’s current work while ensuring data consistency.

This means users can smoothly adjust a component without worrying about a colleague’s comments on the other side of the canvas causing their screen to freeze.

What’s Next for Pixso as a UI/UX Design Platform

Performance optimization is never a project with a finite end, but rather a never-ending journey. As Pixso 2.0 introduces more powerful features (such as more complex animations and deeper AI integration), new performance challenges are inevitable.

Through this complete re-architecture, Pixso 2.0 not only delivers orders of magnitude improvements today, but more importantly, establishes a more solid and flexible engineering foundation to support future development.

The 500,000-layer file that once caused fans to whirr and progress bars to hover now opens quietly in Pixso 2.0, waiting for designers around the world to unleash their creativity without hindrance. And this is just the beginning.