• ⚡ Blazingly Fast: 20-25x performance improvement over pip
• 🔄 Parallel Operations: 16+ concurrent downloads and installations
• 💾 Smart Caching: Multi-level cache (Memory → Disk → Network) with Bloom filters
• 🎯 Zero-Copy Operations: Memory-mapped file access for large packages
• 🔐 Secure: BLAKE3 hash verification (3x faster than SHA256)
• 📦 Dependency Resolution: Advanced SAT solver with topological sorting
• 🌐 HTTP/2 Support: Connection pooling and keep-alive
• 🎨 Beautiful UI: Progress bars and colored output

git clone https://github.com/BasaiCorp/cobra
cd cobra
cargo build --release
sudo cp target/release/cobra /usr/local/bin/

cargo install cobra

cobra init

This creates a cobra.toml configuration file:

[project]
name = "my-project"
version = "0.1.0"
description = "A Python project managed by Cobra"

[dependencies]
requests = "^2.31.0"
numpy = "^1.24.0"

[dev-dependencies]
pytest = "^7.4.0"

[tool.cobra]
python-version = "3.11"
parallel-downloads = 16
cache-enabled = true

# Install all dependencies from cobra.toml
cobra install

# Install without cache
cobra install --no-cache

# Add packages with version
cobra add requests@2.31.0 numpy==1.24.0

# Add latest version
cobra add flask

cobra remove requests numpy

# Update all packages
cobra update

# Update specific package
cobra update --package requests

cobra/
├── src/
│   ├── main.rs              # CLI entry point
│   ├── lib.rs               # Library exports with mimalloc
│   │
│   ├── cli/                 # Command implementations
│   │   ├── init.rs          # Project initialization
│   │   ├── install.rs       # Package installation
│   │   ├── add.rs           # Add dependencies
│   │   ├── remove.rs        # Remove dependencies
│   │   └── update.rs        # Update packages
│   │
│   ├── core/                # Core functionality
│   │   ├── config.rs        # cobra.toml parser
│   │   ├── resolver.rs      # Dependency resolution with SAT solver
│   │   ├── installer.rs     # Parallel package installation
│   │   ├── cache.rs         # Multi-level caching system
│   │   └── python.rs        # Python environment detection
│   │
│   ├── registry/            # Package registries
│   │   ├── client.rs        # Optimized HTTP client
│   │   ├── pypi.rs          # PyPI integration
│   │   └── packagecloud.rs  # PackageCloud.io support
│   │
│   └── utils/               # Utilities
│       ├── progress.rs      # Progress tracking
│       ├── hash.rs          # BLAKE3/SHA256 hashing
│       └── fs.rs            # File system operations

• mimalloc: Custom allocator for 10-15% performance boost
• Zero-copy: Using bytes::Bytes and memory-mapped files
• Efficient data structures: FxHashMap instead of standard HashMap

• Tokio runtime: Work-stealing scheduler
• 16+ concurrent downloads: Semaphore-based rate limiting
• Streaming downloads: Non-blocking I/O with progress tracking
• Parallel dependency resolution: Using Rayon for CPU-bound tasks

┌─────────────────────────────────────┐
│  Memory Cache (LRU, 1000 entries)   │
│         ↓ miss                      │
│  Disk Cache (Sled, content-addressed)│
│         ↓ miss                      │
│  Network (PyPI/PackageCloud)        │
└─────────────────────────────────────┘

• Bloom filters: Fast negative cache lookups
• Content-addressable storage: SHA-256 based keys
• LRU eviction: Automatic memory management

• HTTP/2: Connection multiplexing
• Connection pooling: 32 idle connections per host
• TCP optimizations: tcp_nodelay and keep-alive
• Compression: Gzip and Brotli support

[profile.release]
lto = "fat"              # Link-time optimization
codegen-units = 1        # Better optimization
panic = "abort"          # Smaller binary
opt-level = 3            # Maximum optimization
strip = true             # Remove debug symbols

1. Performance First: Every decision optimized for speed
2. Parallel by Default: Leverage all CPU cores
3. Smart Caching: Cache everything, invalidate intelligently
4. Zero-Copy: Minimize memory allocations
5. Fail Fast: Early validation and clear error messages

1. Fetch metadata for all root dependencies (parallel)
2. Build dependency graph using petgraph
3. Detect circular dependencies
4. Topological sort for install order
5. Cache resolved graphs for future use

1. Check memory cache → disk cache → network
2. Download packages (16 concurrent streams)
3. Verify BLAKE3 hashes in parallel
4. Extract using memory-mapped files
5. Install to site-packages atomically

Contributions are welcome! Please read our Contributing Guide.

MIT License - see LICENSE file for details.

• Inspired by uv and pnpm
• Built with amazing Rust ecosystem libraries
• Thanks to the Python packaging community

• Author: Prathmesh Barot (Basai Corporation)
• Email: basaicorp06@gmail.com
• GitHub: @BasaiCorp