🚨 EXPERIMENTAL FEATURE: AtomCrypte.

⚠️ AtomCrypte is extremely fast on small files, but NOT RECOMMENDED FOR PRODUCTION USE – potential security weaknesses exist.

🔐 AES-256 remains the default encryption algorithm.

What is Atom?:

1. Atom is a file archive tool like RAR or ZIP – but different. Instead of scanning the whole archive, it locates and operates on specific files.
2. Uses Rayon & Tokio for full async + parallelism. Result? 🔥 Blazing-fast performance.
3. Available as a Rust library and CLI (GUI coming soon 👀).

Why Atom?:

1. Atom using full potentional of CPU.
2. Supports both LZ4 and ZSTD – pick between raw speed or tighter compression.

📊 Compression Benchmarks (Without Encryption)

📉 Decompression Benchmarks (Without Encryption)

🧪 CLI Flags

1. -c, --archive -> Set the archive file
2. -a, --add ... -> Add files to the Files
3. -r, --remove ... -> Remove files from the Files
4. -u, --update-files ... -> Update the data block of the Files
5. -x, --extract ... -> Extract files from the Files
6. -e, --encrypt Encrypt the Files
7. -p, --password -> Set the password for the Files
8. -A, --algorithm <algorithm_set> -> Set the algorithm for the Files (Compression Alghorithm's: "lz4/zstd")
9. -C, --compression <compression_level> -> Set the compression level for the Files
10. -l, --list -> List the files in the archive
11. -n, --new -> Creates archive file
12. -N, --name-mapping -> Sets name mapping off (Increases Security)
13. -P, --atomcrypte -> Sets AtomCrypte on/off (EXPERIMENTAL)
14. -h, --help -> Print help
15. -V, --version -> Print version

How to use:

use atom::*;

#[tokio::main]
async fn main() {
    set_algorithm(atom::Algorithms::ZSTD).unwrap();
    set_password("testpassword").unwrap();
    set_zstd_compression_level(10).unwrap();
    set_name_mapping(false).unwrap();
    set_encryption_algorithm(atom::EncryptionAlgorithms::AES)

    let (hash_file_name, file_name) = get_file_names().await.unwrap(); // only works when mapping enabled
    add_data_block(vec!["test.txt" /* ... */], "test", false).await.unwrap();
    remove_data_block(vec!["test.txt" /* ... */], "test").await.unwrap();
    export_file(vec!["test.txt" /* ... */], "test").await.unwrap();
    read_data_block("test.txt", "test").await.unwrap();
    read_multiple_data_block(vec!["test.txt" /* ... */], "test").await.unwrap();
    update_data_block(vec!["test.txt" /* ... */], "test", false).await.unwrap();
}

Which case you should use and you shouldn't use:

⚠️ When not to use Atom:

1. 🚫 Game development – file loading can be slow
2. 🚫 With already compressed files (like .zip, .mp4, etc.)
3. Huge files (1GB+) – works, but performance may suffer

✅ When you should use Atom:

1. ✅ Archiving large groups of small/medium files/large files (200MB+)
2. ✅ Protecting archives with AES-256-GCM
3. ✅ When you want parallel + async + Rust performance

🧪 Wanna try AtomCrypte?

1. CLI (EXPERIMENTAL USE ONLY):

• atom -c archive.atom -a myfile.txt -e -p "supersecret" -P

2. Code (EXPERIMENTAL USE ONLY):

•   set_encryption_algorithm(atom::EncryptionAlgorithms::ATOM)