Deterministic Transformations. Trusted Results.
Generate deterministic transformation plans, decide what actually matters, package them as signed artifacts (DEX), and safely apply large-scale changes with full traceability and lineage.
Dennis Forge is a deterministic transformation engine for software projects. It generates human-reviewable plans, packages them as signed transformation artifacts (DEX), and lets teams safely apply large changes with full traceability. No magic. No lock-in. Just control.
DEX stands for Deterministic EXchange artifact. Dennis doesn't just extract changes. It decides what is meaningful first.
🪓 New: The first public article introducing DEX artifacts is now live on Dev.to.
Dennis is CLI-first and fully open source. The forge concept extends this into shared, portable plans — without changing the deterministic core.
You can run everything locally. Always.
What is Dennis?
Dennis is a deterministic transformation engine that produces portable transformation artifacts called DEX. These artifacts describe exactly what change will occur, allowing teams to inspect, verify, share, and safely apply large modifications across codebases.
Dennis includes a deterministic decision layer that separates meaningful human content from noise (SQL, CSS, identifiers, code artifacts). This ensures that transformations are built on signal, not garbage.
Instead of modifying files blindly, Dennis generates a plan — a human-readable document that shows exactly what will change, before anything is applied.
Every transformation is inspectable, exportable, and reversible. No black boxes. No magic. Just clarity.
Quick Start
Install Dennis globally and generate your first plan in seconds.
pipx install dennisdennis plan ./project --dict en.jsondennis pack plan.json artifact.dexdennis dex sign artifact.dex --key dev.keydennis dex verify artifact.dex
This creates a deterministic transformation plan you can inspect, export, share, and replay safely.
How it Works
Dennis follows a simple, transparent workflow:
- Scan — Analyze the codebase
- Decide — Filter signal from noise (Clean Engine)
- Plan — Generate deterministic transformation plan
- Package — Bundle into DEX artifact
- Sign — Cryptographically sign the artifact
- (optional encrypt) — encrypt as XDEX
- Verify — Validate signatures
- Apply — Execute safely
The plan is the source of truth. Everything flows from it.
DEX Artifacts
Every Dennis plan can be packaged into a DEX artifact — a portable, cryptographically verifiable container that describes a transformation. DEX artifacts can also be encrypted as **XDEX**, allowing organizations to distribute verifiable transformations without exposing the internal transformation logic.
A DEX artifact includes the transformation plan, metadata, and optional signatures. It can be inspected with standard tools, shared between teams, and verified before execution.
Because DEX artifacts are deterministic and content-addressed, they provide a transparent and auditable way to distribute software transformations.
dennis pack plan.json patch.dexdennis dex sign patch.dex --key dev.keydennis inspect patch.dex
DEX artifacts are not just containers. They are deterministic, inspectable, and verifiable representations of change.
Each artifact is linked through lineage — forming a verifiable chain of transformations where every step is hashed and traceable.
Safety & Undo
Every Dennis transformation is reversible by design. The system generates an inverse plan automatically, allowing you to undo changes at any time.
No hidden state. No irreversible migrations. If you can see the plan, you can revert the plan.
This makes Dennis suitable for large refactors, legacy systems, and high-trust environments.
Because transformations are deterministic and artifacts carry lineage, every change can be traced, verified, and audited.
CLI & Open Source
Dennis is built as an open, Git-native tool. The CLI is fully functional and will always remain available.
You can run everything locally, inspect the source, and integrate Dennis into your own workflows.
The web interface builds on top of the same deterministic core — no hidden logic, no proprietary transformations.
Install it globally with:
pipx install dennis
Self-Host or Cloud
Dennis is designed to run wherever you are most comfortable.
Use the CLI locally, deploy it inside your infrastructure, or use the hosted forge when it becomes available.
Your plans remain portable and human-readable, so you are never locked into a single environment.
Why?
Dennis was built to solve a specific problem: How do you safely transform large, complex data structures?
Traditional tools either lack transparency, are too slow, or require irreversible migrations. Dennis solves this by making the transformation plan the source of truth.
It's designed for engineers who need to move fast while maintaining control over their data.
Real Use Cases
Dennis was designed for situations where changes must be transparent, reviewable, and proven authenticity. Because every transformation can be packaged as a signed DEX artifact, Dennis provides a verifiable chain of custody for software changes.
Large Refactors
Plan and review large code transformations before applying them. Teams can inspect the plan, export it for review, and apply it safely across multiple repositories.
Security Patches
Security fixes can be distributed as signed DEX artifacts. Organizations can verify the artifact signature and inspect the transformation plan before applying the patch to their systems.
Language and Framework Migrations
Migrating between frameworks or APIs often requires thousands of small changes. Dennis lets you generate a deterministic plan and replay it safely across many projects.
Audit Trails & Compliance
Each artifact contains a deterministic plan, metadata, and optional cryptographic signatures. This creates a verifiable audit trail showing exactly what changed, when, and by whom.
Chain of Custody for Code Changes
DEX artifacts preserve the history of transformations and signatures. Instead of replacing signatures, Dennis appends them, allowing organizations to maintain a full chain of custody for critical changes and approvals.
Independent Disclosure
Because DEX artifacts are portable and inspectable with standard tools, they can also be used to publish transformations independently of any centralized platform. This enables researchers or auditors to share verifiable evidence of changes while preserving authenticity and traceability.
Forensic Traceability
Track transformations across time. Every artifact records its origin, making it possible to verify not only what changed, but how it evolved.
Philosophy
“An archive is not merely a place where truths are stored. It is a machine built so that tomorrow may still trust yesterday.”