Application performance optimisation in C++ and Rust
NDDev speeds up applications held back by CPU, memory or I/O: we find the bottlenecks by measurement and rewrite them in C++ or Rust. Our RnD practice works with concurrency, cross-platform libraries and computational cores, and backs every speed-up with before-and-after figures. We have written software for clients since 2019.
Who it is for
Product teams whose application slows down under load, whose processing falls behind the data stream, or whose servers cost too much because of slow code.
- Before-and-after measurements
- Bottlenecks rewritten in C++ and Rust
- Concurrency and memory work
- Modules for Python and other languages
Where a speed-up begins
We start by profiling under real load: which functions occupy the CPU, where memory builds up, where the program waits on disk or network. From that map we pick the places where a rewrite will pay off and agree a target in figures with you: response time, throughput or memory use.
- CPU, memory and I/O profiling
- load tests and a target in figures
- bottlenecks rewritten in C++ or Rust
- concurrency and memory work
- modules for Python, Go and other languages
- a report with before-and-after measurements
We rewrite the bottlenecks in C++17/20/23 or Rust and connect them to the rest of the system as a library or module, so the rest of the application keeps its own language. We choose the language for the task and your codebase, and build with CMake, Meson or Rust's standard tooling.
The optimisation cycle
Load snapshot
We take a profile under real load and record the starting figures.
Target in figures
We agree the speed-up you need and which parts of the code we touch, and write it into the specification.
One change at a time
We change the bottlenecks one by one and repeat the measurements after each step.
Before-and-after report
We run the tests and the load, compare behaviour before and after, and deliver the report.
Questions about speeding up applications
Will the whole application have to be rewritten?
Usually only a small part of the code needs speeding up, and that is the part we rewrite. The rest of the application keeps working as before and gets a fast module through a clear interface.
How much faster will it get?
We give a figure after profiling: before measurement, any promise would be a guess. The target goes into the specification, and before-and-after measurements confirm the outcome.
Do you take on code written by another team?
Yes. We read the code and the profile, then propose a plan of changes with the expected gain for each place.
Why C++ and Rust?
Both languages give the control over memory and threads that fast code needs. We write C++17/20/23 and Rust and choose between them based on your codebase and your memory-safety requirements.
How much does optimisation cost?
The cost depends on the size of the code, the depth of the rewrite and the volume of load testing. The starting price is in the price block on this page; we fix the total in the specification after profiling, and writing the specification is part of the price.
from $4,500
- Free warranty
- 40 days
Prices are starting prices for information only and are not a public offer. The final price is fixed in the specification.
Computing and performance
Related
Tell us where your application slows down
Describe the slow operation and the result you need. We will propose a measurement plan.
We reply within 24 hours