What made HERE switch from C++ to Rust?

For decades, HERE has chosen C++ as a go-to language for performance-critical systems. Its raw power, fine-grained control over memory, and mature ecosystem made it indispensable. But in recent years the paradigm has shifted and HERE is switching to Rust.

At HERE, Rust has been successfully used to interface with existing C++ code. The Routing team especially has a lot of experience in this area. One of their projects Matrix Routing service is a HTTP JSON API for calculating routing matrices with a large amount of start and destinations points (e.g. 10,000 x 10,000) in a specified region. It runs mostly on Rust and delivers with ease and accuracy.

The Matrix Routing service supports the following use cases:

Calculate a routing matrix with custom options and dynamic traffic applied, given the origins and destinations are within a certain region with a diameter up to 400 km.
Calculate a routing matrix with routes of arbitrary length given a predefined set of options that can be used with free-flow speed traffic applied.
Calculate a routing matrix with custom options, dynamic traffic, and no region size limitation, for up to 15 origins and 100 destinations or up to 100 origins and one (1) destination.

Learn more about the Matrix Routing Service v8 check out the documentation and examples.

When in 2018 the first prototype of Matrix Routing service was developed in Rust, the team was impressed enough to use it for other services as well. Evangelizing about the project in the company has led to other teams and projects leaning towards Rust and has brought Rustacians (the Rust practitioners and enthusiasts) together for meetings and experience sharing.

What is Rust and why engineers like it?

Rust, designed by Mozilla and first released in 2015, is a systems programming language that promises memory safety without garbage collection, fearless concurrency, and a modern developer experience.

Here is a list of features that engineers at HERE find the most compelling:

Safety and Correctness
- Memory safety (e.g. no use after free, access out of bounds)
- Concurrency safety (single ownership model, "borrow checker" handles references)
- Strong typing
- No access to null pointers
- Many domain problems can be encoded in the type system
- Error handling (forces unpacking of error values)
- Generally catches many more errors at compile time
- No "undefined behavior"
Cross language
- Can interface with C code
- Via C bridging, gives access to many more languages (Python, C++, Java/Scala, JavaScript/TypeScript)
Ecosystem
- Great documentation
  - Standardized API documentation
  - Community generally provides higher quality documentation than many other languages
  - Public crate docs hosted on docs.rs
- Standard package manager (cargo)
- Packages (crates) for many use cases
- OSS licensing for packages is easy (all Apache and/or MIT)
- Standardized code formatter (cargo fmt) and linter (Clippy)
Developer ergonomics
- Easy set up (via rustup tool)
- Fantastic compiler errors
  - Compiler errors are descriptive and human readable
  - Suggestions on how to fix code are often included
  - Dedicated project members working on improving compiler errors
Performance
- Fast execution speed (comparable to C++)
- Low memory overhead
- No garbage collector (low latency)

C++ vs Rust: A Quick Comparison

Feature	Comparison
Memory Management	C++: Manual (prone to leaks, use-after-free) Rust: Ownership model with compile-time safety
Concurrency	C++: Powerful but error-prone Rust: Safe by design with strict compile-time checks
Performance	C++: Excellent Rust: Comparable or better in many real-world benchmarks
Tooling	C++: Fragmented (make, CMake, etc.) Rust: Unified with Cargo, rust-analyzer, and Clippy
Security	C++: Vulnerable to memory bugs Rust: Eliminates entire classes of vulnerabilities
Learning Curve	C++: Steep Rust: Steep but guided by helpful compiler errors
Ecosystem	C++: Mature and vast Rust: Rapidly growing, especially in systems and web dev

Conclusion

The shift from C++ to Rust at HERE is not just a trend — it’s a strategic evolution. As the demands on performance, safety, and maintainability grow, Rust provides an alternative that aligns with modern engineering principles. Its ability to interoperate with existing C++ code has made it a practical choice for gradual adoption, while its robust tooling, safety guarantees, and developer-friendly ecosystem have accelerated its acceptance across teams.

HERE’s adoption of Rust includes: Routing, Traffic Services, Rendering and DevOps; and it is safe to say it reflects a broader movement toward safer, more efficient, and more maintainable systems.

Happy coding and see you in the next one.

[VC1]This sounds like server-side rendering is the first thing that will switch, might be a bit misleading to lead with this.[VC2]This section seems to repeat the table above. Which makes me wonder if you should move the table to the very end?