Skip to content
⁨NDDev RnD⁩, home page
Community
Language: English
Display
Theme
Motion

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

  1. Load snapshot

    We take a profile under real load and record the starting figures.

  2. Target in figures

    We agree the speed-up you need and which parts of the code we touch, and write it into the specification.

  3. One change at a time

    We change the bottlenecks one by one and repeat the measurements after each step.

  4. 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 ₽280,000

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

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

Assistant

Loading the assistant…