Overview The DeepCausality project announces the introduction of Uncertain<T> and the MaybeUncertain<T> types within the deep_causality_uncertain crate. These first-class types provide a robust way to model and propagate uncertainty, ensuring your causal models are reliable.
💡 The Problem with Certainty in an Uncertain World Traditional programming often forces us to represent inherently uncertain data with discrete, “certain” types like f64 or bool. This approach, however, hides the underlying variance and can lead to:
Overview The DeepCausality project is proud to announce the release of DeepCausality 0.11, an update that removes all external dependencies from the default build. This release enhances security, portability, and compilation speed, delivering a self-contained and robust library for computational causality.
🚀 Highlights in 0.11 Zero External Dependencies: The core library has no external dependencies by default. 100% Safe Rust: The entire codebase contains zero unsafe code blocks. Zero Macros: No procedural macros are used in the core library (except for testing). New Internal Crates: deep_causality_rand, deep_causality_num, and deep_causality_tensor. Blazing-Fast Compilation: Full mono-repo builds complete in seconds. 💡 Zero Dependencies by Default The entire DeepCausality codebase, as it is now, compiles by default without any external dependencies.
Sept 19, 2025, JetBrains, the premier software development IDE provider, continues to grant a free all-product license to the DeepCausality project. The project team expresses its sincere gratitude towards JetBrains continuous commitment to the open source community and to the success of the DeepCausality project.
JetBrains Website OSS Community support Blog DeepCausality Website GitHub Blog About DeepCausality is a hyper-geometric computational causality library that enables fast and deterministic context-aware causal reasoning in Rust. Please give us a star on GitHub.
Overview The DeepCausality project announces the release of DeepCausality 0.9 that adds support for the Effect Ethos, a programmable ethos for dynamic adaptive causal inference.
Problem DeepCausality was designed from the ground up to model a dynamic world that is constantly in motion. Its reasoning modes allow us to build systems that use dynamic reasoning models to react to evolving data streams. With adaptive reasoning, they can dynamically alter their own reasoning pathways, choosing the best strategy based on the current context.
Overview When the decision was made to rewrite UltraGraph from scratch for the DeepCausality project, the goal was clear: create a high-performance, memory-efficient, and adaptable graph data structure that is tailor-made for DeepCausality. One of the key requirements was the support for both fast mutation as required by the graph-based context and fast graph traversal as required by the causal reasoning engine. Seasoned engineers will spot immediately the conundrum to solve because data structures that are fast to mutate are fundamentally different from data structures that are fast to analyze. This subsequent quest resulted in deep insights into the trade-offs between flexibility and performance. Here are the key lessons learned along the way.
Overview The DeepCausality project announces the release of DeepCausality 0.8.2. This release includes a series of major updates to the DeepCausality library, introducing powerful new features that significantly enhance its flexibility, robustness, and ease of use.
🚀 Highlights in 0.8.2 Adaptive reasoning Flexible Collection Reasoning with Aggregate Logic Model Assumption Verification Unified PropagatingEffect New code examples 💡 Adaptive Reasoning Previously, causal reasoning flowed strictly along the predefined edges of the graph. Now, with the introduction of the PropagatingEffect::RelayTo variant, a Causaloid can dynamically dispatch the flow of reasoning to any other Causaloid in the graph. This enables sophisticated, adaptive reasoning patterns where the system can choose its own path through the graph, conditional on intermediate results.
Overview The DeepCausality project announces the release of DeepCausality 0.8 that strengthens the core of the framework with added async concurrency, added non-Euclidean context, added relative temporal index, an unified adjustable trait implementation, and unified causal reasoning.
🚀 Highlights in 0.8 Async concurrency full compatibility with Tokio Added unified causal reasoning for deterministic and probabilistic reasoning Added non-Euclidean geometry contexts Added relative temporal index for simplified handling of time graphs. Unified Adjustable trait implementation across all context types ⚡ Added support for Tokio & Async Rust! In DeepCausality 0.8, all Causaloids, Contextoids, and Model types are now able to be Send and Sync, enabling concurrency and thus true parallel inference pipelines. See the new Tokio code example for details about how to build concurrent causal inference with DeepCausality.
Overview Today, the DeepCausality project announces UltraGraph v0.8, a ground-up rewrite of our hypergraph library delivering up to 1,300x speedups, enabling sub-second analytics on 100-million-node graphs, and making billion-node analytics economically feasible on a single machine.
This release introduces a new dual-state architecture designed for the complete lifecycle of graph data. Graphs begin in a flexible DynamicGraph state, optimized for fast, O(1) mutations as the structure evolves. When you’re ready for analysis, a single .freeze() call transforms the graph into a hyper-optimized, immutable CsmGraph based on a cache-friendly Struct of Arrays (SoA) memory layout. This “compilation” step is the key to our performance, virtually eliminating cache misses and unlocking near-linear scaling. If the graph needs to evolve further, simply .unfreeze().
Conventional approaches to computational causality impose familiar structures such as linear time, Euclidean space, and discrete cause-effect sequences onto the systems we seek to model.
However, complex systems with dynamic feedback loops may not adhere to those familiarities and instead emit emergent adaptive behavior that conventional methods of computational causality struggle to grasp. These methods, when applied to complex systems, squeeze the intricateness of reality into the constraints of the modeling approach.
The DeepCausality project has published the “Effect Propagation Process” (EPP), a philosophical framework that informs its Rust implementation. The EPP offers a unified philosophical framework of causality that remains compatible with classical causality and conceptually congruent with physics theories of quantum gravity. Read more in the documentation.
Furthermore, a new articles section was added to the project website to provide easy access to PDF versions of all articles written by the DeepCausality project.
