I engineer deterministic execution kernels, Arrow-native data infrastructure, and low-latency runtimes where correctness is formally verified rather than assumed. Maintainer of Calybris Core, ProofFrame, and ReproCut.
Most software is written for the happy path. I build for the edge cases, the adversarial inputs, and the post-mortems six months later.
- Fail-Closed by Construction: A breached limit, an unexpected type, or an unhandled signal must immediately halt execution — never silently approximate or degrade into undefined behavior.
- Deterministic & Replayable: Eliminating nondeterminism at the kernel level: integer-only fixed-point arithmetic, canonical SHA-256 byte digests, and append-only Write-Ahead Logs (WAL) so any historical state can be replayed and independently audited.
- Hardware-Conscious Runtimes: Mindful of memory layouts, cache lines, zero-copy record batch streaming, and explicit allocation boundaries rather than relying on uncontrolled GC or global allocators.
- Formally Hardened Concurrency: Concurrency is never trusted until thread interleavings are proven with Loom, memory safety is validated with Miri, and state machines survive property-based fuzzing with proptest.
A high-frequency, deterministic decision primitive designed for high-stakes routing, order admission, and policy guardrails. Given a catalog, a policy, and a request; it computes an exact action and seals it with a tamper-evident audit bundle.
- Zero floating-point arithmetic: Fixed-point integer kernel executing at ~115 ns per decision on documented 22-model synthetic workloads (
cargo bench). - Cryptographic Audit Trail: Hash-chained WAL with HMAC and external head anchors detecting even clean suffix truncations.
- Formally Verified Ledger: Concurrent budget accounting (
remaining + reserved + committed == initial) exhaustively checked with Loom for race conditions and Miri for UB. - Portability: Ships as an idiomatic Rust crate (
#![forbid(unsafe_code)]), typed Python package via PyO3, and zero-dependency 237 KB WebAssembly (WASM).
cargo add calybris-core
In-memory contract validation and data integrity engine for PyArrow, Pandas, Polars, and Parquet that evaluates record batches directly in memory without turning rows into Python heap objects.
- Out-of-Core Memory Boundaries: Enforces explicit memory budgets with automatic disk spilling to eliminate OOM kills on massive datasets.
- Cryptographic Lineage: Generates BLAKE3 dataset fingerprints and Ed25519-signed verification receipts for auditable data contracts.
- Zero-Copy Scans: Evaluates exact uniqueness, cross-column assertions, and keyed diffs under strict SIMD-friendly column alignments.
pip install proofframe
An evidence-backed Delta Debugging (ddmin) system that minimizes failing codebases to their smallest reproducible state while guaranteeing the exact failure signature is preserved.
- Multi-Tier Reduction Pipeline: Slices directory/file trees, prunes dependency manifests (
Cargo.toml,pyproject.toml,package.json), and performs syntax node pruning/hoisting via Tree-sitter across multiple languages (Rust, Python, Go, Java, JS, TS, etc.). - Hermetic Isolation: Every candidate evaluation executes in disposable snapshots with OS process-group signal containment (
command-group) and SQLite WAL state checkpointing. - Independent CI Validation: Validated against large real-world repositories (e.g. Bevy Engine, Ipe) inside unprivileged, network-isolated (
--network none) Linux containers.
# Build from source (public pre-release)
cargo install --git https://github.com/emirhuseynrmx/reprocut reprocut-cli --locked| Project | Core Stack | Domain | Architecture Highlights |
|---|---|---|---|
| Aegis | Python XGBoost SHAP DoWhy Litestar |
Decision Engines / Causal ML | Turns uncalibrated probabilities into expected-value actions; provides CATE/uplift modeling and counterfactual recourse. |
| Criteo Uplift Benchmark | Python scikit-learn causal ML |
Statistical Evaluation | Rigorous benchmark comparing S-, T-, X-, and DR-Learners alongside Causal Forests scored with AUUC and Qini curves. |
| Scrape Quality Pipeline | Python asyncio Pydantic v2 Pandera |
Data Engineering | High-concurrency async ingestion with typed runtime contracts, schema drift protection, and partitioned Parquet outputs. |
| Churn & Retention Report | Python scikit-learn SHAP Typst |
Technical Reporting | Calibrated risk scoring and SHAP explainability drivers compiled into automated publication-grade PDFs via Typst. |
Languages : Rust, Python, SQL, Bash
Systems & Core: Tokio, Axum, PyO3, WebAssembly (WASM), Linux (POSIX), Docker
Data Engines : Apache Arrow, Polars, DuckDB, Parquet, SQLite (WAL)
Verification : Loom, Miri, Proptest, Criterion, Pytest
Infrastructure: Linux (Debian/Ubuntu), GitHub Actions (Matrix/Hermetic CI)
Available for full-time engineering roles and contract work — Remote (worldwide) or on-site in Türkiye:
- Rust Systems & Runtime Engineering: High-throughput microservices (Tokio/Axum), deterministic execution kernels, PyO3 native bindings, and WebAssembly compilation.
- Data Infrastructure: Arrow-native data engines, zero-copy record batch streaming, query validation layers, and memory-bounded out-of-core pipelines.
- Correctness, Verification & Safety: Concurrency model checking (Loom), Undefined Behavior elimination (Miri), write-ahead logging (WAL), and hermetic CI/CD test gates.