hpdg

hpdg (High-Performance Data Generator) is a Rust-first data generator for competitive programming and OI workflows.

The project is inspired by Luogu's CYaRon, but it leans into Rust's strengths instead of cloning the Python API one-to-one: strong typing, trait-based extension points, feature flags, reproducible RNG streams, and better composition for larger generators.

Status

hpdg is under active development, but it is no longer just a skeleton:

• The crate is now published on crates.io as hpdg.
• The crate compiles across library, examples, benches, and tests.
• Core generator modules are implemented and usable today.
• The public API is still evolving, so breaking changes are possible before 1.0.
• Python/C binding scaffolding exists, but the Rust crate is the primary supported surface right now.

What Works Today

What Is Still Rough

These parts exist, but they are still early and should be treated as unstable:

• Crate-level documentation and docs.rs polish are still in progress.
• Some modules have broad functionality but still need API cleanup and more examples.
• Python bindings and the C ABI are scaffolding-level rather than polished releases.
• Full CYaRon parity is not the goal; some APIs will stay intentionally more Rust-idiomatic.

Quick Example

use hpdg::graph::Graph;
use hpdg::io::IO;
use hpdg::string::{SentenceConfig, StringGen};
use hpdg::vector::{IntRange, Vector};

fn main() {
    let mut io = IO::new("example".to_string());

    let mut g = Graph::new(5, false);
    g.add_edge(1, 2, None);
    g.add_edge(2, 3, None);

    let vecs = Vector::random_int(3, &[IntRange::Max(10), IntRange::MinMax(5, 8)]);

    let mut cfg = SentenceConfig::default();
    cfg.sentence_terminators = ".".to_string();
    let sentence = StringGen::random_sentence(6, Some(&cfg));

    io.input_writeln("5 2");
    io.input_writeln(format!("{}", g));
    io.input_writeln(vecs.len());
    for v in vecs {
        io.input_writeln(v.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(" "));
    }
    io.input_writeln(sentence);

    let _ = io.flush_to_disk();
}

See also:

• examples/full_generation.rs
• docs/rust-quickstart.md
• docs/cyaron-api.md

Installation

Install from crates.io:

[dependencies]
hpdg = "0.1.0"

You can also browse the published package and API docs here:

• crates.io/crates/hpdg
• docs.rs/hpdg

If you need unreleased changes, you can still depend on the Git repository directly:

[dependencies]
hpdg = { git = "https://github.com/SuperKevinZhou/hpdg" }

Feature Flags

Most generator modules are enabled by default.

Optional integration flags currently include:

• python-bindings
• c-bindings

The remaining feature flags mostly mirror internal module boundaries such as io, graph, math, sequence, vector, string, polygon, query, compare, utils, core, rng, traits, and error.

Project Direction

The long-term goal is to make hpdg a practical Rust alternative to CYaRon for serious OI data generation:

• Keep common workflows concise.
• Prefer deterministic, reproducible generation.
• Provide stronger invariants through types and traits.
• Add Rust-specific building blocks instead of only mirroring Python behavior.

Issues and PRs are welcome.

License

MIT