BitBench
BitBench is a standalone desktop application for controlled bit-level mutation, repeatable corruption testing, experiment logging, and practical learning around bit flipping, data integrity, and format fragility.
It is designed as a workbench, not a toy: a place to load text, JSON, HTML, images, audio, or binary files, apply configurable entropy, inspect the result, and build a real knowledgebase from experiments.
Workbench
A focused desktop instrument for mutation, preview, comparison, and experiment logging.
Knowledge Lab
A browsable internal reference system that explains what bit flipping is and why formats react differently.
Replay Engine
Seeded experiments and logged mutation maps make corruption reproducible instead of mystical.
Core Features
BitBench is built to balance raw entropy with structured analysis. The goal is not merely to damage data, but to understand how and why the damage behaves the way it does.
Input Lab
Load files, inspect metadata, identify format, and establish a clean baseline before mutation.
Mutation Console
Configure intensity, seed, regions, styles, and presets for repeatable or chaotic experiments.
Preview & Diff
Compare original and mutated content through text, binary, and structure-aware views.
Experiment Log
Record input hashes, output hashes, mutation counts, presets, and notes in SQLite.
Mutation Modes
- Random bit flips
- Byte replacement and drift
- Stride and interval corruption
- Cluster shock corruption
- Header-only and footer-only targeting
- Payload/body-only mutation
- Metadata-aware targeting
- Manual surgical offsets
Format Awareness
- Raw binary base injection for any file type
- Printable-safe text mutation
- JSON value mutation with structure preservation
- HTML text-node mutation with optional tag preservation
- Image and audio safe-mode options for header preservation
- Validity notes for renderability and parser survivability
Embedded Knowledgebase
BitBench should teach as well as test. The application includes a browsable knowledge layer that explains the fundamentals, links concepts to live experiments, and helps turn mutation results into useful understanding.
Fundamentals
Bits, bytes, binary numbering, ASCII, Unicode basics, and representation across file types.
Hardware Reality
DRAM, SRAM, charge loss, single event upset, voltage instability, parity, and ECC.
Experimental Interpretation
Why some corruption survives, why some collapses a parser instantly, and how seeds make chaos repeatable.
Application Modules
1. Experiment Manager
Create, save, replay, duplicate, and export mutation sessions.
2. Input Loader
Load from file or text source and generate metadata, hashes, and type detection.
3. Mutation Engine
Apply presets or manual controls using raw or format-aware logic.
4. Preview & Comparison
Inspect text, source, rendered output, and binary impact side by side.
5. Knowledge Layer
Built-in articles, explainers, guided labs, and experiment-linked insights.
6. Output Manager
Save mutated files, reports, notes, and future mutation maps for further study.
Roadmap
The workbench can grow in controlled phases, beginning with a stable core and expanding into richer format-aware behavior, experiment replay, and guided analysis.
Phase 1
GUI shell, file loading, preset controls, mutation engine, experiment logging, and starter knowledge articles.
Phase 2
Structured JSON mutation, HTML-aware mutation, stronger preview behavior, and richer diff summaries.
Phase 3
Image preview, audio metadata and survivability, region targeting, report export, and comparison sessions.
Phase 4
Guided labs, experiment replay, mutation heatmaps, structure scoring, and deeper learning workflows.
Technology Direction
- Python for core engine and desktop application logic
- PySide6 for a standalone, packaging-friendly GUI
- SQLite for experiments, presets, and knowledge articles
- Pillow for image handling and preview support
- Structured handlers for JSON and HTML mutation modes
- PyInstaller for self-contained builds
Design Intent
- Every mutation should be explainable
- Every experiment should be reproducible
- Every output should be savable
- Every result should teach something
- The interface should feel like an instrument, not a form