We have started a long-term effort to improve IDA’s performance across the board.

IDA 9.3 comes with a first pass at eliminating some of the most prominent bottlenecks in the core widgets that make up the IDA UI. These bottlenecks could lead to (sometimes serious) performance penalties when working with large binary files.

Perhaps the most noticeable improvements will be seen when working with large datasets in tabular views (e.g., Functions, Names, Local Types in the left-hand pane, etc.).

What’s new, and why does it matter?

Perhaps the most striking impact of this first pass of refactoring is the removal of (hopefully all) significant slowdowns that could occur when manipulating large selections of items in big datasets:

For example, if you were working on an IDB with, say, ~1 million functions in IDA 9.2, attempting to select a large subset of them (e.g., ~500,000) and move them into a new folder would result in an unpleasant user experience.

IDA 9.3 eliminates this class of slowdown. While working with very large datasets (i.e., large IDBs) will never be as fast as working with small ones, the overall user experience should now be significantly more pleasant. That’s the goal, and if we missed something and you still encounter performance issues, please be sure to let us know (support@hex-rays.com).

Behind the scenes

For the curious, here are a few technical nuggets…

Since its earliest days, IDA has featured tabular views (think Functions, Imports, etc.). Until around 2020, those views were strictly flat.

With IDA 7.5, we introduced a new (and very well-received) feature that allowed users to classify items into groups (i.e., “folders”): https://docs.hex-rays.com/release-notes/7_5#folder-view

In a nutshell, our approach was: “Let’s try to complement our traditionally flat view backend (the venerable chooser_[multi_]t) with a companion data structure that can also be represented as a tree.”

This is why users could toggle folders on and off in certain widgets, such as Functions.

It worked! …but it came with strings attached.

At the time, we thought we could live with those tradeoffs, but we were eventually proven otherwise. We couldn’t find a way to make those widgets perform as fast as they should, and as binary files grew larger and larger, the issue became increasingly visible. There was also a more insidious side effect: the complexity of the code manipulating those large datasets increased significantly as well.

Conceptually, the solution is very simple: move away from those complex widgets and use simpler ones instead. We did exactly that for many widgets in IDA 9.3, including Functions, Names, Local Types, Bookmarks, Imports, and Breakpoints.

…however, this is much easier said than done. Taking the Functions widget as an example, there are a myriad of operations that must be supported: manipulating breakpoints, synchronizing with the listing, querying through the API, and many others. Of course, we couldn’t ship IDA 9.3 without all of that functionality intact.

Closing

For this blog, we mainly focused on tabular views because we believe that was one area that had a lot of room for improvement. The tabular views and other updates which you will find in IDA 9.3 are aimed at improving the overall experience when working with large files.

There are more UI and UX performance gains to be made and we’ll continue looking for them.

Many, many thanks to the IDA users who reported issues — your feedback is invaluable! …and BIG kudos to our beta testers as well: one regression slipped into IDA 9.3b1, but it didn’t make it past [redacted]’s testing!