Performance is not one number.

How to read these results

Dudu compiles source to C++20. A complete build therefore contains work performed by Dudu and work performed by the configured C++ toolchain. Reporting only the final duration would hide which part costs time and would make optimization results difficult to interpret.

Frontend

Lexing, parsing, module resolution, semantic analysis, and diagnostics.

C++ emission

Generating module headers, sources, runtime support, and source mappings.

Native backend

The external C++ compiler and linker. Dudu currently uses the host toolchain.

Generated runtime

The speed and memory use of the finished program after native optimization.

Cold

No reusable result for the measured operation. Operating-system file caches remain warm unless noted.

Incremental

Only invalidated Dudu modules and native objects are rebuilt.

Generated program runtime

The acceptance criterion is parity with equivalent handwritten C++ using the same data structures, operations, compiler, and optimization flags. The current suite uses GCC 13.3 with -O3 -DNDEBUG and 10,000,000 elements or iterations.

The observed range is 0.94-1.03 times handwritten C++. The differences are consistent with measurement and code-layout noise. This suite does not demonstrate a systematic Dudu runtime tax for the operations it covers. It is not a claim about every library, allocator, algorithm, or native API.

./scripts/bench.sh 10000000 --samples 5 \
    --emit-report build/benchmarks/runtime.json

Compiler and toolchain comparison

The compiler matrix generates equivalent programs containing primitive fields, records or classes, methods, functions, calls, and an entry point. The reference workload contains 1,000 units. Frontend and executable production are reported separately where each toolchain exposes both operations.

Frontend checking

Development and incremental build latency

The project-driver fixture contains two Dudu modules and a local native header. Private edits rebuild only the changed generated module. Public interface edits also rebuild dependents. CMake remains responsible for native source and header dependencies.

A no-op build still invokes cmake --build. This is the native dependency check that discovers edits to user C and C++ sources and headers. Dudu preserves generated modification times, skips configure, reports zero dirty modules, and lets CMake skip compilation and linking.

Frontend scaling and C++ emission

The broad scaling matrix generates several source shapes so a fast result for one parser pattern cannot hide a slow semantic path elsewhere. It includes inheritance, expressions, multidimensional indexing, operators, native declarations, and multi-module projects.

The 50k-to-100k curves are approximately linear. A class-heavy path that previously copied the complete symbol graph for every class took 2,651 ms at 50,000 lines; scoped symbol overlays reduced it to 84.8 ms. Follow-up measurements were 155.3 ms at 100,000 lines and 306.9 ms at 200,000 lines.

Generated output size

The compiler comparison's 10,003 lines of Dudu emit 20,023 lines of inspectable self-contained C++. Of those, 4,005 lines are blank and source-location comments consume 185,962 bytes. Removing comments and blank lines leaves 14,256 lines and 288,680 bytes. The remaining expansion is primarily forward declarations, prototypes, and out-of-line method definitions used to preserve declaration order and module boundaries.

Native-header awareness

Dudu uses Clang to import C and C++ declarations for compilation and editor intelligence. Cold scans pay Clang's header parsing cost. Cached checks load Dudu's serialized native metadata.

Direct imports are scanned as one translation unit, with isolated scans only when headers contain conflicting global declarations. Cached native metadata loading for the large fixture itself takes about 18 ms. Timing output separates libclang, AST dump, AST parse, macro preprocessing, cache, and serialization phases.

Editor latency

Each sample starts a fresh language server. Workspace usability is measured through immediate recovering-parser diagnostics. Full semantic and native diagnostics continue on one coalescing background worker. Warm requests run after project and native indexes are populated.

The request probe covers definition, hover, references, completion, semantic tokens, rename, and native-aware hover. With native metadata removed, workspace usability remained 8.2 ms and 7.6 ms; the deliberately native hover then paid a background scan of 3.65 seconds and 1.08 seconds. Native scanning does not block parser diagnostics or unrelated Dudu requests.

Declaration macro compilation

The macro matrix defines 1,000 two-field types and generates one method for each type. Package downloads and the first toolchain dependency bootstrap are excluded. Dudu macro execution itself is about 16 ms; cold application time is dominated by compiling and linking the generated native worker.

Dudu's first SDK cache bootstrap is a separate one-time toolchain operation. Macro packages compile into separate translation units and reuse the stable generated SDK support. Warm and edit paths reuse package and expansion caches by content identity.

Reproduce the measurements

Benchmark harnesses generate their fixtures from source, capture exact compiler commands and versions, retain raw samples, and write structured reports under ignored build directories. The published tables are not typed into tests as expected constants; regression thresholds are maintained separately from informational cross-language comparisons.

# Runtime parity
./scripts/bench.sh 10000000 --samples 5

# Compiler and generated-output scaling
./scripts/bench_compiler.sh --build-type Release --samples 3 \
    --line-scales 10000,50000,100000 \
    --shapes inheritance,expressions,indexing,operators,native,mixed \
    --emit-scaling

# Cross-language compiler matrix
python3 scripts/bench_compiler_compare.py --samples 5

# Native headers
./scripts/bench_native_headers.py --samples 5

# Macro comparison
dudu bench compiler -- --suite macros --samples 5 \
    --compare rust,csharp,swift,nim

Current assessment

• Generated runtime performance is in the intended C++ class for the covered operations.
• The Dudu frontend is competitive with the measured modern-language frontends on the 1,000-unit fixture, but GCC checks equivalent C++ substantially faster.
• Complete clean executable production costs more than direct C++ because Dudu adds frontend and emission work before invoking the C++ backend.
• Per-module emission and CMake-backed incremental builds keep the normal edit loop much shorter than a clean self-contained build.
• Cold large C++ header graphs remain visible. Serialized native metadata makes repeated checks substantially cheaper.
• Warm editor requests are responsive in the current dogfood projects. First native symbol queries can still pay background scanning cost when no metadata cache exists.
• The alpha label reflects compatibility, diagnostics, platforms, ABI stability, and ecosystem work. It does not mean generated programs run through an interpreter.