dinah 0.1.0

A modular Rust foundation for runtime execution, compute, data-oriented systems and simulation.A plain-language overview of DINAH's architecture, current implementation and roadmap.

Version status (updated 2026-10-19): v0.1.0 released and published on crates.io — tag v0.1.0, dated changelog in CHANGELOG.md, package verified with cargo package/cargo publish --dry-run before upload. DINAH remains pre-alpha software: semver 0.x permits breaking changes, and the documented limitations below still apply. Core, Runtime, Memory, Compute and ECS foundations exist; Simulation's first five bounded models are implemented. Phase 7 (Networking) has completed points 120–139: API boundaries, the blocking byte-stream transport contract, logical message envelope and versioned binary wire format are documented; initial TCP connection and listening-endpoint wrappers are implemented. The wire encoder/decoder remains unimplemented; local connection lifecycle state is tracked; generic client-side prediction, bounded input history, reconciliation and replay primitives are implemented; application-level retry bookkeeping, RTT estimation, explicit liveness/backoff policy, bounded Runtime dispatch, tick-based simulation delivery, deterministic loss/latency simulation and a Networking benchmark suite are present. Full protocol/domain integration and automatic reconnection remain pending. A green CI gate validates the checks that ran; it is not a claim of API stability beyond the frozen v0.1 surface or of performance guarantees.

Repository snapshot (2026-10-19): 287 master checklist points · 279 complete · 0 in progress · 8 deferred by design (tracked as v0.2 goals in puntos2.md) Code snapshot: single Rust crate · 7 benchmark suites (Runtime, Memory, Compute, ECS, Simulation, Networking, Storage) · 8 runnable examples · five-platform benchmark history Current milestone: v0.1.0 is released and published on crates.io: the v0.1 public API surface and architecture are frozen (docs/public-api-review.md, docs/integration-matrix.md), the full local verification suite passed on the release commit, and the package is live at cargo add dinah. Native foundations include safe host/POSIX capability traits and a minimal scalar C ABI; the scalar ABI has passed a real C compiler/linker smoke test in CI; this is a limited ABI check, not broad cross-target compatibility. No direct hardware access or handwritten assembly is claimed. Networking has initial blocking TCP wrappers and prediction/reconciliation/replay primitives, but its wire encoder/decoder and full protocol integration remain pending (v0.2 cycle, roadmap2.md).

DINAH is a modular systems-software project written primarily in Rust. It is building reusable foundations for task execution, memory management, compute workloads, entity-component data and deterministic simulation, with networking and other capabilities planned in staged roadmap phases.

DINAH is not a finished general-purpose runtime or a game engine. The roadmap expresses direction; the master checklist records implementation status. APIs can change while the project is pre-alpha.

The design separates shared contracts from runtime execution, storage and compute concerns. Simulation builds on these foundations. Networking has initial TCP byte-stream wrappers and bounded reliability/simulation helpers, but no completed wire encoder/decoder or production network stack. Storage now has an in-memory key-value API, append-only journal with CRC-32 checksums and legacy v1 replay, ordered borrowed iteration, and an explicit bounded Runtime mutation queue; it is not a transactional database.

1. Correctness before optimization. Define contracts, failure behaviour and tests before tuning performance.
2. Measure before claiming. Benchmark results need reproducible inputs, recorded environments and retained artifacts.
3. Rust-first and memory-safe. Lower-level languages are considered only when a measured technical need justifies them.
4. Determinism where promised. Ordering, time, state transitions and error handling must be explicit and tested.
5. Small, justified dependency surface. Dependencies require a concrete purpose and a maintainable upgrade path.
6. Evidence-driven progress. A design document is not proof of implementation; checklist points close only with appropriate code and validation evidence.

Requirements: Rust 1.95 or newer (verified MSRV) and Git. The crate uses Rust edition 2021 and has no runtime dependencies. Platform-specific performance measurements are collected by CI and are not universal hardware comparisons.

Implemented foundations include: runtime scheduling and task execution; memory buffers; sequential and parallel compute operations; generational ECS entities and sparse-set component storage; fixed-step simulation and five focused simulation models; CI, benchmark and documentation workflows.

Not yet complete: a production SIMD kernel, full parallel ECS system execution, full wire framing/serialization and authenticated transport, transactional storage and compaction, direct hardware integration, full CLI manifest/TOML compatibility, automatic observability, coverage-guided fuzzing and full-system application validation — all scheduled in the v0.2 cycle (roadmap2.md). A limited C ABI smoke test and focused integration pipelines now run in CI; neither implies broad cross-target ABI support or a production application. See the master checklist for exact status rather than treating planned work as shipped.

DINAH tracks median timings for the simulation clock, simulation step, mutable entity traversal and repeated linear searches. The recorded five-platform CI matrix below is historical evidence from workflow run 38484605568, commit 83cbcc3; it is not a controlled cross-OS comparison or a performance guarantee. The full suite (Runtime, Memory, Compute, ECS, Simulation, Networking, Storage) was also executed locally on the v0.1.0 release commit and archived by CI in artifacts/. Lower timings are better for these measurements.

These are medians of nine samples; construction is included in the clock and step cases. A lightweight compute kernel also showed that dispatch overhead can make parallel execution slower than sequential execution. Benchmark history and metadata are archived in artifacts/README.md. SIMD and data-oriented layout work remain open until representative workloads justify changes.

Released — v0.1.0 (2026-10-19). The 287-point v0.1 checklist is closed: 279 complete, 0 in progress, 8 deferred by design and now tracked as v0.2 goals in puntos2.md. The v0.1 scope ended at point 277; points 278–287 (the v0.2 design cycle) were completed as the design recorded in roadmap2.md and puntos2.md (puntos 288–326). Release evidence: fmt/clippy/tests/doc-tests/benchmarks green on the release commit, cargo package and cargo publish --dry-run verified, MSRV pinned to Rust 1.95 (verified empirically), changelog dated. Networking remains a pre-alpha foundation with wire encoder/decoder and full protocol integration pending — now scheduled as Phase 18 of the v0.2 cycle.

Deferred by design (retaken as v0.2 goals in puntos2.md; see roadmap.md for the v0.1 context):

The CLI baseline and opt-in observability primitives are implemented; tracing, metrics and profiling still require explicit caller reporting and are not automatic. The v0.2 cycle (fases 18–23 in roadmap2.md) covers wire framing and event codec, public ECS queries, full TOML, optional sandboxing, atomic journal transactions, branch coverage, fuzzing and evidence-based optimization. Checklist counts measure tracked work items, not percentage of release effort. See roadmap.md, roadmap2.md, the 287-point master checklist and the v0.2 checklist.

Published on crates.io:

cargo add dinah

Or directly from the repository:

git clone https://github.com/lecodev-26/dinah.git
cd dinah
cargo build --release

The library API is pre-alpha and can change between minor versions while below 1.0. Start with docs/compute.md or docs/simulation.md for implemented APIs. CI is the validation gate; benchmark claims should be checked against the corresponding run artifacts.

CI is used to validate code and documentation incrementally. Passing CI is evidence that the configured checks passed for a particular commit; it does not certify production readiness, API stability or a performance level.

Unless a file states otherwise, DINAH is dual-licensed under your choice of the MIT License or the Apache License, Version 2.0. Contributions intended for inclusion follow the same dual-license terms unless explicitly agreed otherwise.