Real-Time Graphics Overlays in ArcGIS Maps SDKs for Native Apps: Benchmark and Tips

Real-time situational awareness apps depend on a current view of moving assets and changing conditions. As positions, headings, and status updates arrive, users need to understand what is happening without losing spatial context while they pan, zoom, or move between 2D and 3D. A public safety dispatcher may follow responders approaching a changing hazard. A defense operator tracks aircraft, vessels, and ground units across a wider area. In either case, the map must absorb a continuous stream of updates while keeping symbols meaningful and interaction responsive.

ArcGIS Maps SDKs for Native Apps support two approaches to displaying real-time moving data: graphics overlays, which are well suited to extremely dynamic scenarios with high-frequency updates, and Dynamic Entities, which are purpose-built for highly dynamic streaming feeds, previous observations, and track visualization. Both approaches support high-frequency updates, and the appropriate choice depends on the workflow. This article focuses on graphics overlays, and a future article will cover Dynamic Entities.

To explore how graphics overlays perform under a sustained stream of moving data, we built a benchmark application and measured its update rate during active map interaction.

The test

The benchmark application, built with ArcGIS Maps SDK for Qt, tests whether an app can keep rich, meaningful symbols on screen while updating them very fast. Its workload moves air, ground, sea, and subsurface graphics independently while the user pans and zooms.

Each graphic uses a MIL-STD-2525C military symbol. A symbol may identify an aircraft as friendly, show its direction of travel, and carry status that affects a user’s response. Anonymous points would be simpler to draw but would lose that information, so the benchmark keeps full symbology. The result is a varied operational picture rather than a field of identical markers. Each symbol conveys information about the object it represents.

The symbols come from one shared dictionary renderer. A dictionary renderer connects each graphic’s attributes to a standards-based symbol. ArcGIS Maps SDKs for Native Apps use dictionary styles provided by Esri that support the US (MIL-STD-2525) and NATO (APP-6) standards. Developers can also create custom dictionary styles that combine their own symbols and expected attributes.

The graphics live in graphics overlays, which display content above a map or scene. Dynamic rendering keeps graphic representations on the GPU, allowing the SDK to update moving graphics without redrawing the underlying map data for every change.

Live metrics tracked generated observations, applied graphic updates, and frame-related measures.

The results

On the Windows 11 test system described above, the application reached a peak rate of approximately 800,000 applied graphic updates per second across 10,000 moving graphics while maintaining a stable frame rate during pan and zoom. That’s an average of 80 applied updates per graphic per second, equivalent to updating each graphic every 12.5 milliseconds. This peak focused on location updates; direction and other renderer-driving attributes remained unchanged. Changing those attributes adds work to the update path and may reduce the achievable update rate.  

Live metrics tracked generated observations, applied graphic updates, and frame-related measures. The benchmark brings together the SDK’s rendering capabilities and practical Qt techniques for keeping each update efficient. Results vary with hardware, view type, symbol complexity, graphic count, and update content. 

Tips, tricks, and best practices

Sustaining a high update rate across many graphics requires the application to limit the work in each update. For the ArcGIS Maps SDK for Qt benchmark, we designed the update path around the guidelines captured in the ArcGIS Maps SDK for Qt performance guide. The list below follows those guidelines and shows how we applied them in the benchmark. You can use it as a set of tips for improving performance in your own app.

1. Create each graphic once – The application updates a graphic’s geometry as it moves instead of rebuilding the display.
2. Share overlays and renderers – Compatible graphics share overlays and renderers, and initial graphics enter their collections in batches.
3. Use direct graphic lookup – A `QHash` connects each stable ID to its graphic, allowing incoming observations to reach the right object without scanning the overlay.
4. Match the view’s spatial reference – The benchmark generates points in the view’s spatial reference, avoiding reprojection on each location update.
5. Limit updated content and reuse capacity – Each benchmark observation contains only the location and attributes required for the current visualization. Geometry-only workloads skip dictionary attributes, and the generator reuses container capacity to reduce allocation pressure during sustained runs.
6. Move pure data preparation off the GUI thread – Qt’s worker-object pattern moves simulation and pure data preparation onto a dedicated `QThread`. Prepared observations arrive in controlled batches, and the application prevents a growing backlog when an incoming feed outruns the view.

These choices preserve more capacity for drawing the operational picture and responding to the person using it. 

From moving graphics to operational applications

Rendering moving assets is one part of an operational application. Developers can combine graphics overlays with hosted and local content, support connected and disconnected workflows, and present data in 2D maps and 3D scenes within the same mapping SDK. Geotriggers and spatial analysis can help applications respond to location changes and turn incoming data into actionable information.

ArcGIS Maps SDKs for Native Apps provide a foundation for responsive 2D and 3D applications across supported desktop and mobile platforms. Explore the performance demo to see the benchmark in action, consult Performance considerations in the guide for ArcGIS Maps SDK for Qt to apply these techniques, and browse our Qt key features page and our Qt samples to explore what else you can build.

Data sources used in this blog

Data sources and credits for the benchmark application are listed in the ArcGIS Maps SDK for Qt performance demo README.