TechCompressor is a production-ready, modular Python compression framework featuring multiple algorithms, military-grade encryption, solid compression with dictionary persistence, PAR2-style recovery records, advanced file filtering, multi-volume archives, incremental backups, and both CLI and GUI interfaces. Built for performance, security, and RAR-competitive features.
- LZW (Lempel-Ziv-Welch): Fast dictionary-based compression, ideal for repetitive data
- Huffman Coding: Optimal for data with non-uniform frequency distributions
- DEFLATE: Industry-standard hybrid (LZ77 + Huffman), best overall compression
- STORED: Automatic detection and direct storage of incompressible files
- Solid Compression: Dictionary persistence across files for 10-30% better ratios
- Recovery Records: PAR2-style Reed-Solomon error correction (0-10% redundancy)
- Multi-threaded: Parallel per-file compression for 2-4x faster archives
- Smart AUTO mode: Entropy detection and algorithm selection heuristics
- Advanced File Filtering (v1.2.0): Exclude patterns (*.tmp, .git/), size limits, date ranges
- Multi-Volume Archives (v1.2.0): Split large archives into parts (archive.tc.001, .002, etc.)
- Incremental Backups (v1.2.0): Only compress changed files since last archive
- Enhanced Entropy Detection (v1.2.0): Auto-skip compression on JPG, PNG, MP4, ZIP, etc.
- AES-256-GCM: Authenticated encryption with integrity verification
- PBKDF2: 100,000 iterations for brute-force resistance
- Password-protected compression with seamless integration
- No backdoors or recovery mechanisms
- TCAF v2 Format: Custom TechCompressor Archive Format with backward compatibility
- Compress entire folders with metadata preservation
- Supports both per-file and single-stream compression
- Path traversal protection and security validation
- Preserves timestamps, permissions, and relative paths
- Recovery records for archive repair and corruption detection
- Archive Metadata (v1.2.0): User comments, creation date, creator information
- File Attributes (v1.2.0): Windows ACLs and Linux extended attributes preservation
- CLI: Full-featured command-line with benchmarking and verification
- GUI: User-friendly Tkinter interface with background threading
- Python API: Direct module imports for automation scripts
- Encryption overhead < 10% for typical use cases
- Streaming support for large files (>16MB)
- Optimized I/O operations and buffer handling
- Multi-threaded GUI operations (non-blocking)
⚠️ Windows Users (v1.2.0): The pre-built executable may trigger antivirus warnings due to new Windows ACL and multi-volume features. This is a false positive. See Antivirus False Positives for verification steps and workarounds. v1.0.0/v1.1.0 are not affected.
# Clone repository
git clone https://github.com/DevaanshPathak/TechCompressor.git
cd TechCompressor
# Install dependencies
pip install -r requirements.txt
# Run tests
pytest
# Launch GUI
python -m techcompressor.cli --guiCommand Line:
# Compress a file
techcompressor compress input.txt output.tc --algo DEFLATE
# Create encrypted archive
techcompressor create folder/ archive.tc --algo DEFLATE --password mypassword
# Extract archive
techcompressor extract archive.tc output/ --password mypassword
# Verify archive integrity
techcompressor verify archive.tc
# Run performance benchmark
techcompressor --benchmarkPython API:
from techcompressor.core import compress, decompress
from techcompressor.archiver import create_archive, extract_archive
# Simple compression
data = b"Hello, World!"
compressed = compress(data, algo="DEFLATE")
original = decompress(compressed, algo="DEFLATE")
# With encryption
compressed = compress(data, algo="DEFLATE", password="secret")
original = decompress(compressed, algo="DEFLATE", password="secret")
# Archive folder with all v1.2.0 features
create_archive(
source_path="my_folder/",
archive_path="backup.tc",
algo="DEFLATE",
password="secret",
per_file=False, # Single-stream for best compression
recovery_percent=5.0, # v1.1.0: 5% recovery records
max_workers=4, # Parallel compression
exclude_patterns=["*.tmp", ".git/", "__pycache__/"], # v1.2.0: File filtering
max_file_size=100*1024*1024, # v1.2.0: Max 100MB per file
min_file_size=1024, # v1.2.0: Skip files < 1KB
incremental=True, # v1.2.0: Only changed files
volume_size=650*1024*1024, # v1.2.0: Split into 650MB volumes (CD-size)
preserve_attributes=True, # v1.2.0: Windows ACLs / Linux xattrs
comment="Monthly backup", # v1.2.0: Archive metadata
creator="Backup Script v2.0" # v1.2.0: Creator info
)
# Extract archive with attributes
extract_archive("backup.tc", "restored/", password="secret", restore_attributes=True)GUI Application:
# Launch GUI
python -m techcompressor.gui
# Or via CLI flag
techcompressor --guiHow does TechCompressor compare to ZIP, RAR, and 7-Zip? Here's a comprehensive breakdown:
| Feature | TechCompressor | ZIP | RAR | 7-Zip |
|---|---|---|---|---|
| Open Source | [YES] MIT License | [YES] Public Domain | [NO] Proprietary | [YES] LGPL |
| Compression Algorithms | LZW, Huffman, DEFLATE | DEFLATE | RAR (proprietary) | LZMA, LZMA2, DEFLATE |
| Best Compression Ratio | ****☆ (99%+ on repetitive) | ***☆☆ | ***** (industry best) | ***** |
| Compression Speed | ****☆ (3-6 MB/s) | ****☆ | **☆☆☆ (slow) | ***☆☆ |
| Solid Compression | [YES] v1.1.0 (10-30% better) | [NO] | [YES] | [YES] |
| Recovery Records | [YES] v1.1.0 (PAR2-style) | [NO] | [YES] | [NO] |
| Multi-threading | [YES] v1.1.0 (per-file) | [LIMITED] Limited | [YES] | [YES] |
| Encryption | AES-256-GCM (100K iterations) | AES-256 (ZipCrypto weak) | AES-256 | AES-256 |
| Smart Storage Mode | [YES] Auto-detects incompressible | [NO] Always compresses | [YES] | [YES] |
| Archive Metadata | [YES] v1.2.0 (comments, dates) | Timestamps | Full metadata | Full metadata |
| File Filtering | [YES] v1.2.0 (patterns, size, date) | [NO] | [LIMITED] Limited | [LIMITED] Limited |
| Multi-Volume Archives | [YES] v1.2.0 (configurable) | [YES] | [YES] | [YES] |
| Incremental Backups | [YES] v1.2.0 (timestamp-based) | [NO] | [LIMITED] Via WinRAR | [NO] |
| File Attributes | [YES] v1.2.0 (ACLs, xattrs) | [LIMITED] Limited | [YES] | [LIMITED] Limited |
| Python API | [YES] Native | [LIMITED] Via zipfile | [NO] | [LIMITED] Via py7zr |
| GUI Included | [YES] Cross-platform | [NO] OS-dependent | [YES] Commercial | [YES] |
| Format Compatibility | TCAF v2 (custom) | Universal | Universal | Universal |
| Multi-algorithm Choice | [YES] 3 algorithms + AUTO | [NO] DEFLATE only | [NO] RAR only | [YES] Multiple |
| Use Case | Development, scripting, automation | General purpose | Maximum compression | Open-source alternative |
- Developer-Friendly: Native Python API with clean, documented interface
- Security-First: Stronger key derivation (100K iterations vs. ZIP's weak encryption)
- Smart Compression: STORED mode saves time/space on incompressible files (PNGs, videos, archives)
- Algorithm Choice: Pick the best tool for your data (LZW for speed, DEFLATE for ratio, Huffman for text)
- Archive Flexibility: Per-file or single-stream compression modes
- Truly Open: MIT licensed, no restrictions, fully inspectable code
Best For:
- Python applications needing compression
- Automated backup scripts
- Development/testing compression algorithms
- Scenarios requiring strong encryption with password
- Mixed content (text + images) archives
[NO] Not Ideal For:
- Maximum compression ratio (use 7-Zip/RAR)
- Universal format compatibility (use ZIP)
- Extremely large files >10GB (use specialized tools)
| Algorithm | Best For | Speed | Compression | Memory | Notes |
|---|---|---|---|---|---|
| DEFLATE | General purpose | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | Medium | Recommended default |
| LZW | Repetitive data | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | Low | Fastest compression |
| Huffman | Frequency-skewed | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | Low | Good for text |
Tested on 10KB repetitive text data:
Algorithm Time Ratio Speed
--------------------------------------------------
DEFLATE 2.33 ms 1.0% 6.14 MB/s Best
LZW 4.72 ms 8.9% 3.03 MB/s Fastest
HUFFMAN 5.82 ms 43.7% 2.46 MB/s
| File Type | Algorithm | Archive Mode | Reason |
|---|---|---|---|
| Text/Source Code | DEFLATE | Single-stream | Best compression for similar content |
| Office Documents | DEFLATE | Per-file | Mixed content with metadata |
| Binary/Executables | LZW | Per-file | Fast, handles binary well |
| Media Files | AUTO | Per-file | Auto-detects incompressible, uses STORED |
| Large Files (>100MB) | DEFLATE | Single-stream | Streaming support, best ratio |
# Full benchmark suite
python bench.py
# Quick performance check
python bench.py --quick
# CLI benchmark
techcompressor --benchmarkTechCompressor v1.2.0 may trigger warnings from Windows Defender and Chrome browser, while v1.0.0 and v1.1.0 do not. This is a false positive caused by new features in v1.2.0, not actual malware.
Important: ✅ VirusTotal shows ZERO detections (all 70+ engines pass). This confirms the file is safe - only Windows Defender's local heuristics are triggering.
Version-Specific Triggers (Why Only v1.2.0):
-
Windows ACL Operations (New in v1.2.0):
- File attributes preservation accesses Windows Access Control Lists (ACLs)
- Uses
pywin32library to read/write security descriptors - Windows Defender heuristics flag ACL access as "suspicious behavior"
- v1.0.0/v1.1.0 didn't touch ACLs → no warnings
-
Multi-Volume File I/O (New in v1.2.0):
- Creates multiple sequential files (.001, .002, etc.)
- Complex file splitting/joining patterns look "unusual" to local scanners
- v1.0.0/v1.1.0 created single files → no pattern matching
-
Increased Executable Size:
- v1.2.0: ~18-22MB (includes pywin32, multi-volume code)
- v1.1.0: ~15-17MB
- v1.0.0: ~14-16MB
- Larger binaries trigger deeper heuristic analysis
-
PyInstaller Bundling Pattern:
- Bundled dependencies changed between versions
- Windows Defender uses behavioral analysis on first run
- v1.0.0/v1.1.0 have established local reputation over time
YES - This is definitively a false positive. Here's the proof:
1. VirusTotal Scan Results (CRITICAL PROOF)
- ✅ 0 detections out of 70+ antivirus engines (as of October 2025)
- ✅ Scanned by: Microsoft Defender (cloud), Kaspersky, Bitdefender, McAfee, Norton, Avast, AVG, ESET, Trend Micro, and 60+ others
- ✅ All major vendors confirm: CLEAN
- 🔗 Verify yourself: Upload to VirusTotal.com
Why does Windows Defender flag it locally but not on VirusTotal?
- Windows Defender uses local heuristics (behavioral analysis on your PC)
- VirusTotal uses cloud definitions (crowd-sourced intelligence)
- Local heuristics are more aggressive but less accurate → false positives
- Cloud definitions have global context → accurate results
2. Check the SHA256 Hash
# Windows PowerShell
Get-FileHash TechCompressor.exe -Algorithm SHA256
# Compare against official hash (published in release notes)3. Source Code Verification
- All code is open source: https://github.com/DevaanshPathak/TechCompressor
- Build from source yourself:
.\build_release.ps1 - Compare your build's hash with official release
Option 1: Add Exclusion (Recommended)
Since VirusTotal confirms the file is clean, adding an exclusion is completely safe:
# Windows Defender - PowerShell (Administrator)
Add-MpPreference -ExclusionPath "C:\Path\To\TechCompressor.exe"
# Verify exclusion
Get-MpPreference | Select-Object -ExpandProperty ExclusionPathOption 2: Use v1.1.0 Instead
- Download v1.1.0 from releases (no Windows Defender warnings)
- You'll lose: multi-volume archives, file attributes, incremental backups
- Core compression features work identically
Option 3: Build from Source
# Clone repository
git clone https://github.com/DevaanshPathak/TechCompressor.git
cd TechCompressor
# Activate virtual environment
.venv\Scripts\Activate.ps1
# Install dependencies
pip install -r requirements.txt
# Build executable (requires PyInstaller)
.\build_release.ps1
# Your self-built executable won't trigger warnings (no signature mismatch)Code signing certificates cost $200-$500/year and require a legal entity (not available for open-source hobby projects).
However: Since VirusTotal shows 0 detections from 70+ engines, the file is objectively safe. The Windows Defender local heuristic issue will likely resolve itself over time as more users download and report it as a false positive.
Since VirusTotal confirms the file is clean, you can confidently report this to Microsoft:
-
Microsoft Defender False Positive Form: https://www.microsoft.com/en-us/wdsi/filesubmission
- Submit the executable with SHA256 hash
- Category: "I believe this file is incorrectly detected"
- Include VirusTotal link showing 0 detections
-
The more users report it, the faster Microsoft will whitelist it.
-
Star the GitHub repo (social proof helps build trust): https://github.com/DevaanshPathak/TechCompressor
This issue affects ONLY v1.2.0 due to new Windows ACL and multi-volume features. Earlier versions (v1.0.0, v1.1.0) do not trigger warnings because they don't perform these operations.
Good News: VirusTotal's perfect score (0 detections) means this is purely a local Windows Defender heuristics issue, not a real security concern.
We're working on v1.3.0 (Q1 2026) to eliminate these Windows Defender triggers without paid code signing:
Planned Fixes (100% Free):
- Optional pywin32: ACL operations become opt-in only (no bundled pywin32 in default build) → Removes primary trigger
- Smaller Executable: 35-45% size reduction (10-13MB vs 18-22MB) → Less aggressive scanning
- Refactored I/O Patterns: Less "suspicious" multi-volume file operations → Avoid behavioral detection
- Submit to Microsoft: Proactive false positive reporting before release → Build reputation
- Transparent Builds: GitHub Actions CI/CD with public logs → User trust
Expected Result: Windows Defender heuristics will stop flagging the executable (based on file size reduction and behavior changes).
- Algorithm: AES-256-GCM (Galois/Counter Mode)
- Key Derivation: PBKDF2-HMAC-SHA256
- Iterations: 100,000 (adjustable, default for security)
- Key Size: 256 bits
- Salt: 16 bytes (random per encryption)
- Nonce: 12 bytes (random per encryption)
- Authentication Tag: 16 bytes
- Use strong, unique passwords (12+ characters)
- Store passwords in a password manager
- No password = permanent data loss (no recovery)
- Encrypted archives include integrity verification
- Path traversal protection prevents malicious archives
- Symlinks rejected to avoid infinite loops
- Password Loss = Data Loss: No backdoors or recovery mechanisms
- Compression Leaks Info: Data patterns visible despite encryption
- PBKDF2 Intentionally Slow: ~50-100ms for key derivation (security feature)
Global Options:
techcompressor --version # Show version
techcompressor --benchmark # Run performance test
techcompressor --gui # Launch GUI
techcompressor --help # Show helpCompression Commands:
# Compress single file
techcompressor compress INPUT OUTPUT [--algo ALGO] [--password PASS]
# Decompress single file
techcompressor decompress INPUT OUTPUT [--algo ALGO] [--password PASS]Archive Commands:
# Create archive
techcompressor create SOURCE ARCHIVE [--algo ALGO] [--password PASS] [--per-file]
# Extract archive
techcompressor extract ARCHIVE DEST [--password PASS]
# List contents
techcompressor list ARCHIVE
# Verify integrity
techcompressor verify ARCHIVEExamples:
# Compress with DEFLATE
techcompressor compress file.txt file.tc --algo DEFLATE
# Create encrypted archive (single-stream)
techcompressor create project/ backup.tc --algo DEFLATE --password "secure123"
# Extract with password
techcompressor extract backup.tc restored/ --password "secure123"
# Verify archive
techcompressor verify backup.tc
[YES] Valid TCAF archive
[YES] Contains 42 file(s)
Original: 1,234,567 bytes
Compressed: 345,678 bytes (28.0%)
[YES] Archive verification passed!Core Compression:
from techcompressor.core import compress, decompress
# Basic compression
compressed = compress(data, algo="LZW")
original = decompress(compressed, algo="LZW")
# With password
compressed = compress(data, algo="DEFLATE", password="secret")
original = decompress(compressed, algo="DEFLATE", password="secret")
# Available algorithms: "LZW", "HUFFMAN", "DEFLATE"Archiver:
from techcompressor.archiver import create_archive, extract_archive, list_contents
# Create archive with v1.2.0 features
create_archive(
source_path="folder/",
archive_path="backup.tc",
algo="DEFLATE", # Compression algorithm
password="secret", # Optional encryption
per_file=False, # False = single-stream (better compression)
recovery_percent=5.0, # v1.1.0: PAR2-style recovery (5% redundancy)
max_workers=4, # Parallel compression threads
exclude_patterns=["*.tmp"], # v1.2.0: Exclude files by pattern
max_file_size=100*1024*1024, # v1.2.0: Max file size (100MB)
min_file_size=1024, # v1.2.0: Min file size (1KB)
volume_size=650*1024*1024, # v1.2.0: Split into 650MB volumes
preserve_attributes=True, # v1.2.0: Save ACLs/xattrs
incremental=True, # v1.2.0: Only changed files
comment="Backup 2025-10-27", # v1.2.0: Archive comment
creator="Backup Script", # v1.2.0: Creator info
progress_callback=None # Optional callback(current, total)
)
# Extract archive with attribute restoration
extract_archive(
archive_path="backup.tc", # Or backup.tc.001 for multi-volume
dest_path="output/",
password="secret",
restore_attributes=True, # v1.2.0: Restore ACLs/xattrs
progress_callback=None
)
# List contents (no extraction)
contents = list_contents("backup.tc")
for entry in contents:
if 'name' in entry: # File entry
print(f"{entry['name']}: {entry['size']} bytes → {entry['compressed_size']} bytes")
elif 'metadata' in entry: # Archive metadata
print(f"Created: {entry['metadata'].get('creation_date')}")
print(f"Comment: {entry['metadata'].get('comment')}")
**GUI Application:**
```python
from techcompressor.gui import TechCompressorApp
# Launch GUI programmatically
app = TechCompressorApp()
app.run()
Compress Tab:
- Browse file or folder to compress
- Choose output archive location
- Select algorithm (LZW, Huffman, DEFLATE)
- Toggle per-file archive mode
- Enter password with show/hide
- Real-time progress bar and log
Extract Tab:
- Browse archive to extract
- Choose destination folder
- Enter decryption password
- Progress tracking with file list
- Cancel support
Settings Tab:
- Compression level adjustment
- Default archive mode selection
- Help text and tooltips
Logs Tab:
- View all application logs
- Auto-scroll to latest
- Clear logs button
Keyboard Shortcuts:
Ctrl+Shift+C: Quick compressCtrl+Shift+E: Quick extract
Coverage:
- 193 tests passing (3 skipped on some platforms)
- Core compression algorithms (LZW, Huffman, DEFLATE)
- Encryption and key derivation
- Archive creation and extraction (per-file & single-stream)
- Multi-volume archives (10 tests)
- File attributes preservation (10 tests, 3 platform-specific)
- GUI components (headless mode)
- Performance and timing
- Integration tests
- Edge cases and error handling
Run Tests:
# All tests
pytest
# Specific test file
pytest tests/test_lzw.py -v
# With coverage
pytest --cov=techcompressor --cov-report=html
# Performance tests only
pytest tests/test_perf_sanity.py -v
# Quick test
pytest -qTest Categories:
test_lzw.py: LZW compression (16 tests)test_huffman.py: Huffman coding (20 tests)test_deflate.py: DEFLATE compression (21 tests)test_crypto.py: Encryption and security (15 tests)test_archiver.py: Archive management (28 tests - includes v1.2.0 features)test_multi_volume.py: Multi-volume archives (10 tests)test_file_attributes.py: File attributes preservation (10 tests)test_integration.py: Cross-algorithm tests (34 tests)test_gui_basic.py: GUI components (11 tests)test_perf_sanity.py: Performance validation (6 tests)test_release_smoke.py: Pre-release sanity checks (14 tests)test_sanity.py: Import validation (1 test)test_gui_basic.py: GUI components (11 tests)test_perf_sanity.py: Performance checks (6 tests)
Q: Which algorithm should I use?
- General purpose: DEFLATE (best compression ratio)
- Speed priority: LZW (fastest compression)
- Text/code projects: DEFLATE with single-stream
- Binary/media files: LZW with per-file mode
Q: What's the difference between per-file and single-stream?
- Per-file: Each file compressed independently (good for random access)
- Single-stream: All files concatenated then compressed (better compression)
- Use per-file for mixed content, single-stream for similar files
Q: Can I use this in production?
- Yes! Version 1.0.0 is production-ready
- Extensively tested (137 tests)
- Used for personal and commercial projects
- MIT licensed (see LICENSE file)
Q: Why is encryption slow?
- PBKDF2 uses 100,000 iterations for security
- First encryption takes ~50-100ms for key derivation
- This protects against brute-force attacks
- Subsequent operations are faster
Q: How do I recover a lost password?
- You cannot. This is by design for security
- No backdoors or recovery mechanisms
- Always store passwords securely
- Consider keeping unencrypted backups of critical data
Q: Is TechCompressor secure?
- Uses industry-standard AES-256-GCM
- PBKDF2 with 100,000 iterations
- Authenticated encryption prevents tampering
- However, compression can leak some data patterns
Q: Why does the GUI freeze?
- It shouldn't! All operations run in background threads
- If frozen, it's a bug - please report with reproduction steps
- Check Logs tab for error messages
Q: Can I cancel a long operation?
- GUI: Click "Cancel" button (graceful shutdown in 1-2 seconds)
- CLI: Press
Ctrl+C(immediate termination) - Partial files may remain (safe to delete)
Q: How do I install Tkinter?
- Windows/macOS: Included with Python by default
- Linux (Debian/Ubuntu):
sudo apt-get install python3-tk - Linux (Fedora):
sudo dnf install python3-tkinter
Q: What file formats are supported?
- Input: Any file type (binary safe)
- Output:
.tc(TechCompressor format) - Archives use TCAF (TechCompressor Archive Format)
- Compressed files have format-specific headers
TechCompressor/
├── techcompressor/ # Main package
│ ├── __init__.py # Version and exports
│ ├── core.py # Compression algorithms
│ ├── crypto.py # Encryption (AES-256-GCM)
│ ├── archiver.py # Archive management (TCAF)
│ ├── cli.py # Command-line interface
│ ├── gui.py # Tkinter GUI
│ └── utils.py # Logging and utilities
├── tests/ # Test suite (137 tests)
├── bench.py # Benchmark tool
├── requirements.txt # Dependencies
├── pyproject.toml # Package configuration
├── LICENSE # MIT License
└── README.md # This file
- Python: >= 3.10
- Dependencies:
cryptography>=41.0.0- AES encryptiontqdm>=4.65.0- Progress bars
- Optional: Tkinter (GUI, included with most Python installations)
Contributions welcome! Please:
- Fork the repository
- Create a feature branch
- Add tests for new features
- Ensure all tests pass (
pytest) - Submit a pull request
# Install in development mode
pip install -e .
# Run tests
pytest
# Run benchmarks
python bench.py
# Build wheel
python -m build- [YES] LZW, Huffman, DEFLATE algorithms
- [YES] AES-256-GCM encryption
- [YES] TCAF archive format
- [YES] CLI and GUI interfaces
- [YES] Comprehensive test suite
- [YES] Performance benchmarks
- [YES] Cross-platform support
- Arithmetic coding algorithm
- Brotli/Zstandard integration
- Parallel compression for multi-core
- Cloud storage integration
- Python package on PyPI
- Standalone executables (PyInstaller)
This project is licensed under the MIT License.
MIT License
Copyright (c) 2025 Devaansh Pathak
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
- LZW Algorithm: Terry Welch (1984)
- Huffman Coding: David A. Huffman (1952)
- DEFLATE Format: Phil Katz, RFC 1951 (1996)
- Cryptography: Python
cryptographylibrary - Testing: pytest framework
- GUI: Python Tkinter
- GitHub: DevaanshPathak/TechCompressor
- Issues: Report bugs or request features
- License: MIT (see LICENSE file)
TechCompressor 1.0.0 - Built with for efficient, secure compression
