dry-validation-rust

The description states that dry-validation-rust is a hybrid Ruby/Rust validation engine designed to accelerate structural validation while preserving Ruby business rules. The author, Alexey Tomilov, describes it as a developer tool intended for experimentation and feasibility testing, not a production-ready drop-in replacement for dry-validation.

Key elements from the self-reported description:

• It uses Rust for expensive structural work (key normalization, schema traversal, coercion, etc.) and Ruby for expressive business logic.
• The project is presented as an explicitly tested compatibility subset with clear boundaries between what belongs in each language.
• It includes a safe namespace (Dry::Validation::Rust) to allow side-by-side evaluation with existing code.
• Benchmarking is done via isolated processes to ensure reproducibility and avoid misleading results.
• GPT-5.6 and Codex were used for architecture review, problem identification, and roadmap generation, but the core product decisions remained with the author.

This is a developer tool, not a commercial product or service. There is no revenue, customers, or adoption data provided. The description does not indicate any funding rounds, headcount, or market traction.

The description states that dry-validation-rust is:

• A hybrid Ruby/Rust validation engine
• Built using native extensions (via Magnus and rb-sys)
• Designed to handle structural validation in Rust while preserving Ruby for business logic
• Uses a familiar contract-style DSL
• Implements key normalization, schema traversal, coercion, nested structures, and error handling in Rust
• Keeps Ruby for rule blocks, macros, options, context, and injected domain objects

The product is described as:

• Not a full replacement for dry-validation
• An explicitly tested compatibility subset
• A feasibility-stage developer tool
• Not presented as complete compatibility or production-ready

The description states that the project was inspired by:

• The desire to keep Ruby where it's expressive
• Moving expensive structural work to Rust
• Avoiding full rewrites of dry-validation
• Preserving Ruby's value in business rule blocks, macros, and domain objects

Key claims made:

• "Keep Ruby where Ruby is expressive. Use Rust where Ruby becomes expensive."
• The project is not a production-ready drop-in replacement
• It is an explicitly tested compatibility subset
• Unsupported behavior must fail loudly
• The architecture is designed to be trustworthy through boundary management

The positioning evolved from:

• Initial feasibility prototype (before OpenAI Build Week)
• To a mature, reproducible, and honest tool
• With clear documentation of what it supports and doesn't support

The description states that this project targets:

• Developers working with Ruby validation
• Those interested in performance optimization through hybrid language approaches
• Users who want to preserve Ruby's expressiveness while accelerating structural work

The target customer profile appears to be:

• Individual developers or small teams building Ruby applications
• People experimenting with Rust integration in Ruby projects
• Developers looking for performance improvements without sacrificing Ruby's expressiveness

No specific customer segments, personas, or use cases are detailed beyond the general developer audience.

Not evidenced. The description does not contain any information about:

• Revenue streams
• Pricing models
• Monetization strategies
• Customer acquisition costs
• Unit economics

This appears to be a developer tool without commercial revenue or pricing information.

The description states that the technical implementation includes:

• Ruby layer defining contracts and turning schemas into execution plans
• Rust native extension built with Cargo, connected to CRuby through Magnus and rb-sys
• Separate processes for benchmarking to avoid namespace collisions
• Comprehensive testing including Ruby and Rust tests, compatibility fixtures, CI across supported platforms
• Benchmark tooling with raw measurements, environment metadata, workload-specific conclusions

Delivery signals:

• Repository includes documentation, package checks, security checks, verification scripts
• Benchmark design runs implementations in separate processes
• Emphasis on making claims checkable through executable evidence
• Explicit delivery gates and repository instructions

Not evidenced. The description does not contain any information about:

• Customer adoption or usage
• Revenue or financial performance
• Market traction or growth metrics
• User feedback or testimonials
• Product-market fit indicators

The project is described as a feasibility-stage developer tool, with no mention of production deployment or user base.

Not evidenced. The description does not contain any information about:

• Competitors in the validation space
• Market positioning relative to existing solutions
• Competitive advantages or disadvantages
• Industry benchmarks or standards

The author mentions dry-validation as a reference point but doesn't compare against other tools or market offerings.

Inferences based on self-reported information:

1. Limited commercial viability: As a developer tool without revenue streams, it may not be suitable for investment or partnership consideration.
2. High technical complexity: Hybrid language development (Ruby/Rust) introduces significant complexity in boundary management, error propagation, and performance optimization.
3. Unclear market demand: No evidence of customer interest or commercial traction suggests limited market validation.
4. Dependency on author's expertise: With only one team member, the project's sustainability is tied to individual capacity.
5. Performance claims may not translate: Benchmarking in isolated processes doesn't guarantee real-world performance improvements.
6. Limited scope: The project is explicitly described as a compatibility subset, not a full replacement.

1. What specific performance improvements have been observed in real-world usage compared to upstream dry-validation?
2. How does the hybrid approach handle edge cases and error propagation between Ruby and Rust layers?
3. What is the actual adoption rate among developers who have tried this tool?
4. Are there any plans for broader compatibility or production deployment beyond the current feasibility stage?
5. How do you plan to maintain and evolve this hybrid architecture over time?
6. What are the practical limitations of using this in production environments?
7. Have you identified any specific use cases where this approach provides clear value over pure Ruby or pure Rust solutions?