Skip to content

CONTRIBUTING.md

Latest commit

 

History

History
213 lines (148 loc) · 3.57 KB

CONTRIBUTING.md

File metadata and controls

213 lines (148 loc) · 3.57 KB

Contributing to DeepLossless

DeepLossless is an experimental inference-aware runtime for long-running AI coding sessions.

The project focuses on:

  • execution reuse
  • semantic memory
  • replayable inference
  • context compaction
  • long-session stability

This is still an early-stage systems project, and contributions are very welcome.

Philosophy

DeepLossless is NOT trying to:

  • become another chatbot wrapper
  • maximize prompt size
  • blindly stuff more context into models

Instead, the goal is to explore:

Long context windows are not memory.

We treat AI execution more like:

  • incremental compilation
  • replayable runtime systems
  • execution state management

Good First Contribution Areas

You do NOT need to understand the entire runtime to contribute.

Especially welcome:

Dashboard / Visualization (HIGH PRIORITY)

We currently have almost no visualization tooling.

Ideas:

  • execution timeline viewer
  • cache hit/miss dashboard
  • replay inspector
  • semantic DAG explorer
  • token usage graphs
  • execution provenance viewer
  • failure-memory timeline

This is one of the most impactful areas for contributors right now.

Benchmarking & Metrics

Help improve:

  • benchmark scenarios
  • token accounting
  • runtime statistics
  • cache effectiveness reporting
  • long-session simulations

CLI / Developer Experience

Examples:

  • better logs
  • colored output
  • trace formatting
  • replay debugging tools
  • config UX improvements

Tree-sitter / Language Support

Help expand:

  • AST extraction
  • symbol tracking
  • semantic compression
  • language adapters

Documentation

Especially helpful:

  • architecture diagrams
  • execution flow explanations
  • benchmark walkthroughs
  • replay examples
  • tutorial sessions

Development Setup

git clone ...
cargo test
cargo bench

Useful tests:

cargo test --test simulated_session -- --nocapture
cargo test --test long_session_benchmark -- --nocapture

Project Structure

High-level overview:

Client
  ↓
Proxy / Runtime Interception
  ↓
Execution Normalization
  ↓
Cache / Replay / Memory Layer
  ↓
Upstream LLM

Key components:

Component Purpose
Runtime interception + replay
DAG memory semantic execution graph
Cache layer tool reuse
Failure memory prevent repeated bad reasoning
Snapshot system replayable execution
Compression layer entropy-aware compaction

Areas That Are Still Experimental

Some systems are intentionally evolving rapidly:

  • replay architecture
  • mutation engine
  • execution snapshots
  • memory evolution
  • context injection policies

Please open discussions before large refactors.

Contributor-Friendly Areas

These are especially safe to work on:

  • dashboards
  • visualization
  • metrics
  • documentation
  • CLI improvements
  • benchmark tooling

Before Opening Large PRs

Please open:

  • an issue
  • discussion
  • design sketch

especially for:

  • replay semantics
  • DAG mutation
  • cache invalidation
  • execution scheduling

Why This Project Exists

Long-running AI coding sessions slowly degrade over time.

Agents:

  • reread the same files
  • repeat failed fixes
  • rebuild the same plans
  • waste reasoning and tokens

DeepLossless explores whether AI execution can become:

  • incremental
  • replayable
  • reusable
  • memory-aware

rather than stateless prompt reconstruction.

Thanks for checking out the project. Even small contributions help a lot.