Release builds got slower
Compare compiler configs, benchmark before and after, and keep the result tied to the exact flags that produced it.
Useful for backend services, engines, SDKs, and tools.Measurement-first C and C++ optimization
TurboBuild scans your C++ codebase, tests correctness, benchmarks compiler flags, profiles hot paths, and shows exactly what changed. It is a local CLI for teams that need proof before they change release flags, rewrite hot code, or ship performance claims.
What it solves
TurboBuild gives C and C++ teams one repeatable path from project readiness to measured optimization reports.
Compare compiler configs, benchmark before and after, and keep the result tied to the exact flags that produced it.
Useful for backend services, engines, SDKs, and tools.
Try size-focused configs like -Os, -Oz,
and LTO while keeping unsafe tradeoffs visible.
Run strict warnings, categorize risks, and write JSON output that can be reviewed in CI or attached to tickets.
Useful for code cleanup and production readiness.
Keep semantic-changing flags like -Ofast and
-ffast-math behind explicit opt-ins.
Platform
TurboBuild keeps optimization grounded in correctness checks, repeatable builds, and before-and-after measurements.
Detect CMake, Make, Ninja, C and C++ sources, headers, tests, benchmarks, generated files, compilers, and supported flags.
Run warning analysis, sanitizer builds, static heuristics, and project tests before treating a candidate as valid.
Compare safe compiler configurations, benchmark repeated runs, and report latency, throughput, failures, and artifact size.
Produce JSON and HTML reports showing what was tested, what passed, and whether an improvement was actually measured.
Under the hood
The CLI does normal build engineering work: inspect the project, probe compilers, run safe configs, measure the command, and write files your team can review.
std::vector<Order> orders;
for (const auto& event : feed) {
orders.push_back(parse_order(event));
}
// TurboBuild finding:
// repeated vector growth in measured path
orders.reserve(feed.size());
Find CMake, source files, headers, tests, benchmarks, generated code, and build outputs.
Check GCC/Clang availability and supported flags like -O2, -O3, -Os, -Oz, and LTO.
Run warmups and repeated samples, then calculate mean, median, p95, p99, throughput, failures, and artifact size.
Write JSON and HTML under .turbobuild/results so the result can be reviewed or uploaded by CI.
Finding: repeated vector growth
Suggested experiment: reserve container capacity
Run: turbobuild benchmark --runs 100 --warmups 5 --command ".\app.exe"
$ turbobuild optimize --goal speed --runs 100 --warmups 5 --benchmark-command ".\app.exe"
[doctor] cmake found, gcc found, clang found
[build] gcc-o2 artifact=1.92 MB mean=52.4 ms p99=81.2 ms
[build] gcc-o3 artifact=1.86 MB mean=45.6 ms p99=70.8 ms
[build] gcc-o2-lto artifact=1.70 MB mean=42.8 ms p99=67.1 ms
[report] wrote .turbobuild/results/optimize-summary.json
How teams use it
Run it locally while investigating a change, then move the same checks into CI when the workflow becomes part of release quality.
Confirm compilers, build system, tests, benchmarks, and analysis tools.
turbobuild doctor --project .
Generate isolated builds under .turbobuild/builds.
turbobuild build --project . --config gcc-o2
Run warmups and repeated samples before calling anything faster.
turbobuild optimize --goal speed --benchmark-command ".\app.exe"
Write JSON and HTML output under .turbobuild/results.
turbobuild report --format html
Optimizer lab
Pick a project profile and goal. The preview builds a command, shows the run plan, and keeps the benchmark settings easy to check.
turbobuild optimize --project .\project --goal speed --runs 100 --warmups 5 --benchmark-command ".\app.exe --scenario production"
Runbook
This is the high-level operating model for teams using TurboBuild across internal C++ services, tools, simulations, engines, and libraries.
Start with a local path today. The hosted product waitlist is designed around uploading a zipped C++ project and receiving a readiness scan.
turbobuild analyze --project path\to\project
Run warnings, sanitizers, static analysis, and tests before any performance claim is accepted.
turbobuild warnings --project path\to\project --strict
Run warmups and repeated samples across compiler configurations. TurboBuild tracks p50, p95, p99, mean, standard deviation, and throughput.
turbobuild optimize --goal speed --benchmark-command ".\app.exe"
Export reports for engineering review, release notes, or business signoff. No unmeasured speedup claims are reported as wins.
turbobuild report --project path\to\project --format html
C++ findings
TurboBuild reports concrete C++ patterns that deserve measurement: allocation churn, cache locality issues, branch behavior, I/O flushes, unsafe casts, sanitizer failures, and compiler flag differences.
std::vector<Order> orders;
for (const auto& event : feed) {
orders.push_back(parse_order(event)); // finding: repeated growth
}
// Candidate to measure:
orders.reserve(feed.size());
TurboBuild marks this as a candidate, then requires benchmark data before claiming a win.
for (const auto& row : report) {
out << row.symbol << "," << row.price << std::endl;
}
// Candidate to measure:
out << row.symbol << "," << row.price << '\n';
std::endl flushes the stream. TurboBuild flags it when it appears in likely hot paths.
bool has_prefix(const std::string& value,
const std::string& prefix) {
return value.rfind(prefix, 0) == 0;
}
// Candidate to measure:
bool has_prefix(std::string_view value,
std::string_view prefix) {
return value.starts_with(prefix);
}
TurboBuild highlights avoidable string copies and suggests a measured experiment, not an automatic rewrite.
struct Particle {
float x, y, z;
float vx, vy, vz;
};
std::vector<Particle> particles;
// Candidate for hot loops:
struct ParticlesSoA {
std::vector<float> x, y, z;
std::vector<float> vx, vy, vz;
};
Cache-sensitive layouts are reported as high-impact candidates when profiling points at tight loops.
Safe candidates:
-O2
-O3
-Os
-Oz
-O2 -flto
Explicit opt-in only:
-Ofast
-ffast-math
-march=native
Semantic-changing or portability-changing flags stay blocked unless the team opts in.
Example reports
TurboBuild turns command-line work into readable reports: what was tested, what passed, which flags were used, and what actually improved.
Goal: reduce p95 request time without changing floating-point behavior.
Goal: shrink the binary while keeping the same test result.
Goal: block risky optimization until correctness checks pass.
Command center
Copy the commands that match your optimization stage. Each one
writes structured results under .turbobuild/results.
Check readiness before running deeper optimization work.
turbobuild doctor --project path\to\project
Discover project shape, compilers, flags, tests, and build systems.
turbobuild analyze --project path\to\project
Run strict compiler warnings and categorize correctness risks.
turbobuild warnings --project path\to\project --strict
Collect warmups, repeated runs, percentiles, and throughput.
turbobuild benchmark --runs 100 --warmups 5 --command ".\app.exe"
Test safe candidate configs and pick the best measured result.
turbobuild optimize --goal speed --benchmark-command ".\app.exe"
Create a GitHub Actions workflow for readiness and reports.
turbobuild init-ci --project path\to\project
Project intake
A hosted version could turn TurboBuild into a team workflow: upload a project archive, choose a goal, run tests and benchmarks, and receive a reviewed optimization report.
Early access
Get notified when project upload, managed optimizer runs, report history, team review, and business dashboards are ready.