Use it carefully! Please create backup copy before use it.
Please verify content of each archive.
Run only 1 active instance of the program!

How does it work?
Ultra F-A archiver repacks your archives using all possible compression algorithms, trying (sorting) different algorithms for each file type (there is a selection by file extension). At the end, it creates the smallest possible archive size (i.e. it optimizes the original archive, the content does not change!). This is why it is quite a long process (several times longer than simply creating an archive), but it will not affect the speed of unpacking the archive, it will still be very fast (unlike other superarchivers like PAQ, where you have to wait for hours to unpack, here it takes only a few seconds or even less). The compression gain can be up to 10-20% for certain types of files! If the optimized archive is the same size as the original one or larger, the program will leave the original archive unchanged, i.e. you will not lose anything in size in any case.

Thus, the program can also be used as a regular Converter from various types of archives (7z, zip, rar, etc.) to ARC archives.

Ultra F-A archiver 1.05 (c) 2026 supercompression.org
FreeArc 0.67a (c) 2014 Bulat.Ziganshin@gmail.com
https://ru.wikipedia.org/wiki/FreeArc

For daily use, I recommend the “Good” mode, it is fast enough and gives good results. For better compression, use the “Best” or “Ultra” modes. The “Extreme” and “Extreme2” modes can be selected if the archive size is small enough (up to 10-50 MB), or if you want to get maximum compression despite a fairly long repacking process. If you have more than 4 GB of RAM, you can increase the size of the LZMA dictionary to 256 MB and PPMD to 1024 MB, which can further improve compression. Also, a small improvement usually gives an increase of the parameter “LZMA word Size” to 273.

Download Ultra F-A archiver 1.05 (35 Mb):
Download here (35 mb)
Mirror 1
Mirror 2
Mirror 3

Features:
– Auto switch LZMA/PPMD/GRZIP/EXE/DISPACK/DELTA/DICT/LZP/REP/TTA during creation ARC-archives (+ improved (tuned) lzma for jpg, bmp, wav, exe…)
– Full compatible with original ARC format.
– High compression ratio – better than non tuned FreeArc original.
– Supported formats: ARC, 7z, ZIP, ZIPX, CAB, RAR, ARJ, LZH, GZIP, BZIP2, Z, CHM, ISO, NSIS, TAR, CPIO, RPM and DEB (formats supported by 7-zip/FreeArc).
– External compressors: PRECOMP, SREP, ZPAQ, LPAQ8, FP8, PAQ8PX, MCM, Kanzi, Razor, Durilca, Nanozip.

You can download original FreeArc installer or portable (zip). Also you can use Peazip Archiver for compress/extract ARC files.

FreeArc is an archiver featuring:
* best speed and compression ratio among all practical archivers
* dedicated algorithms for multimedia, executable and text compression
* compression dictionaries up to 2gb
* solid archives with smart updating
* AES+Twofish+Serpent encryption
* recovery record
* self-extracting archives
* extraction of zip, rar, 7z, gz, bz2, cab and many other archive formats
* integration with Explorer, Total Commander, FAR manager and InnoSetup
* GUI and console versions both for Windows and Linux
* free for commercial and non-commercial use

Program optimizes your file to new one with «_optimized» name ending (source file will remain intact).

External compressors:
FreeArc, SREP – https://en.wikipedia.org/wiki/FreeArc
PRECOMP – http://schnaader.info/precomp.php
ZPAQ – https://mattmahoney.net/dc/zpaq.html
LPAQ8 – https://mattmahoney.net/dc/#lpaq
FP8 – https://encode.su/threads/613-FP8-(-Fast-PAQ8)
PAQ8PX – https://github.com/hxim/paq8px
MCM – https://github.com/mathieuchartier/mcm
Kanzi – https://github.com/flanglet/kanzi-cpp
Razor – https://encode.su/threads/2829-RAZOR-strong-LZ-based-archiver
Durilca – https://www.compression.ru/ds/
NanoZip – https://encode.su/threads/111-NanoZip-a-new-archiver-using-bwt-lz-cm-etc

Current archive has its own status in the list: «running», «done» and «saved space».
Full stats:
1. Number of optimized files (total and current session).
2. Files in the queue (quantity).
3. Saved disk space (Mb) total and for each archive in the list.

It’ free for commercial and non-commercial use!
If you like my program and you want help improve it, you can help me (donate) here.
Contact me at maxcompress@ya.ru

History:
2026-01-27
Ultra F-A archiver 1.05
– improved compression:
— added multi-threaded Durilca+4×4 (faster);
— added multi-threaded FP8+4×4 (faster);
— added multi-threaded PAQ8PX+4×4 (faster);
— added 4/6-threaded PPMD+4×4 for large files (faster);
— added LZMA:ht4:1gb (better for large files);
— improved compression for some files (internal methods);
– added fastest methods with deduplication: rep/srep+LZ4, rep/srep+Tor:3, m4;
– added option “Use current direcory instead of system TEMP”;
– added option “Hide banner”;
– update 7-zip 25.01, Kanzi 2.4, FP8v6;
– internal optimizations.

2025-04-12 – v.1.04
– improved compression (added external compressors: MCM 0.85, Durilca 0.5, Nanozip 0.09a)
– improved compression for some files (internal methods)
– added 2-threaded PPMD+4×4 for large files (faster)
– update 7-zip 24.09
– internal optimizations

2024-12-15 – v.1.03 – first release.

Download Ultra F-A archiver 1.05 (35 Mb):
Download here (35 mb)
Mirror 1
Mirror 2
Mirror 3

The post Ultra F-A archiver 1.05 first appeared on Super Compression - useful programs/tools and information!.

Download Ultra Compression Params Generator 1.02 (8 Mb):
Download here (8 mb)
Mirror 1
Mirror 2
Mirror 3

BSC is a high performance file compressor based on lossless, block-sorting data compression algorithms.

Copyright (c) 2009-2024 Ilya Grebnov <ilya.grebnov@gmail.com>
See file AUTHORS for a full list of contributors.

More info about BSC available at official site

Features:
The source code is available under Apache License Version 2.0.
GPU acceleration using NVIDIA CUDA technology.
64 bit and multi-core systems support.
Highly optimized code and C++ interface for superior performance.
Multiple algorithms that allows software fine-tuning for maximum speed or compression efficiency.
CRC-32 calculation routine for data integrity verification.
In-place compression and decompression to save memory.

Block sorting algorithm:
-m0 – Burrows Wheeler Transform
-m3..8 – Sort Transform of order n.

Contexts for sorting:
-cf Following contexts
-cp Preceding contexts
-ca Autodetect (experimental)

Entropy encoding algorithm:
-e0 Fast Quantized Local Frequency Coding
-e1 Static Quantized Local Frequency Coding
-e2 Adaptive Quantized Local Frequency Coding (best compression)

Preprocessing options:
-p Disable all preprocessing techniques
-s Enable segmentation (adaptive block size), default: disable
-r Enable structured data reordering, default: disable
-l Enable Lempel-Ziv preprocessing, default: enable
-H LZP dictionary size in bits, default: -H15, minimum: -H10, maximum: -H28
-M LZP minimum match length, default: -M128, minimum: -M4, maximum: -M255

Platform specific options:
-G Enable Sort Transform acceleration on NVIDIA GPU, default: disable
-P Enable large 2MB RAM pages, default: disable
-t Disable parallel blocks processing, default: enable
-T Disable multi-core systems support, default: enable

Memory usage:
bsc compresses large files in blocks. Multiple blocks can be processed in parallel on multiple-core CPU. At decompression time, the block size used for compression is read from the header of the compressed file. The block size and number of blocks processed in parallel affects both the compression ratio achieved, and the amount of memory needed for compression and decompression. Compression and decompression requirements are the same and in bytes, can be estimated as 16Mb + 5 x block size x number of blocks processed in parallel.

GPU memory usage for NVIDIA CUDA technology is different from CPU memory usage and can be estimated as 20 x block size for ST, 21 x block size for forward BWT and 7 x block size for inverse BWT.

—————————————————————–

Kanzi is a modern, modular, portable and efficient lossless data compressor implemented in C++.

Kanzi 2.3 (c) Frederic Langlet
Credits: Matt Mahoney, Yann Collet, Jan Ondrus, Yuta Mori, Ilya Muravyov,
Neal Burns, Fabian Giesen, Jarek Duda, Ilya Grebnov

More info about Kanzi available at official site

modern: state-of-the-art algorithms are implemented and multi-core CPUs can take advantage of the built-in multi-threading.
modular: entropy codec and a combination of transforms can be provided at runtime to best match the kind of data to compress.
portable: many OSes, compilers and C++ versions are supported (see below).
expandable: clean design with heavy use of interfaces as contracts makes integrating and expanding the code easy. No dependencies.
efficient: the code is optimized for efficiency (trade-off between compression ratio and speed).

Unlike the most common lossless data compressors, Kanzi uses a variety of different compression algorithms and supports a wider range of compression ratios as a result. Most usual compressors do not take advantage of the many cores and threads available on modern CPUs (what a waste!). Kanzi is multithreaded by design and uses several threads by default to compress blocks concurrently. It is not compatible with standard compression formats.

Kanzi is a lossless data compressor, not an archiver. It uses checksums (optional but recommended) to validate data integrity but does not have a mechanism for data recovery. It also lacks data deduplication across files. However, Kanzi generates a bitstream that is seekable (one or several consecutive blocks can be decompressed without the need for the whole bitstream to be decompressed).

There are a few scenarios where Kanzi could be a better choice:
gzip, lzma, brotli, zstd are all LZ based. It means that they can reach certain compression ratios only. Kanzi also makes use of BWT and CM which can compress beyond what LZ can do.

These LZ based compressors are well suited for software distribution (one compression / many decompressions) due to their fast decompression (but low compression speed at high compression ratios). There are other scenarios where compression speed is critical: when data is generated before being compressed and consumed (one compression / one decompression) or during backups (many compressions / one decompression).

Kanzi has built-in customized data transforms (multimedia, utf, text, dna, …) that can be chosen and combined at compression time to better compress specific kinds of data.

Kanzi can take advantage of the multiple cores of a modern CPU to improve performance

It is easy to implement a new transform or entropy codec to either test an idea or improve compression ratio on specific kinds of data.

The Block compressor cuts the input file into blocks (the size can be provided on the command line with the ‘block’ option up to 1GB). Optionally, a checksum for the chunk of data can be computed and stored in the output.

As a first step, it applies one or several transforms (default is BWT+MTFT+ZRLT) to turn the block into a smaller number of bytes. Up to 8 transforms can be provided. EG: BWT+RANK+ZRLT.

As a second step, entropy coding is performed (to turn the block into a smaller number of bits).

Available transforms:
BWT: Burrows Wheeler Transform (https://en.wikipedia.org/wiki/Burrows-Wheeler_transform) is a transform that reorders symbols in a (reversible) way that is more amenable to entropy coding. This implementation uses a linear time foward transform and parallel inverse tranform.
BWTS: Burrows Wheeler Transform by Scott is a bijective variant of the BWT (slower).
LZ: Lempel Ziv (https://en.wikipedia.org/wiki/LZ77_and_LZ78). An implementation of the dictionary based LZ77 transform that removes redundancy in the data.
LZX: Lempel Ziv Extra. Same as above with a bigger hash table and/or extra match checks.
RLT: Run Length Transform (https://en.wikipedia.org/wiki/Run-length_encoding). A simple transform that replaces runs of similar symbols with a compact representation.
ZRLT: Zero Run Length Transform. Similar to RLT but only processes runs of 0. Usually used post BWT.
MTFT: Move-To-Front Transform (https://en.wikipedia.org/wiki/Move-to-front_transform). A transform that reduces entropy by assigning shorter symbols to recent data (works like a LRU cache). Usually used post BWT.
RANK: Rank Transform: A transform that that reduces entropy by assigning shorter symbols based on symbol frequency ranks. Usually used post BWT.
EXE: A transform that reduces the entropy of executable files (X86 & ARM64) by replacing relative jump addresses with absolute ones.
TEXT: A text transform that uses a dictionary to replace common words with their index.
ROLZ: Reduced Offset Lempel Ziv. An implementation of LZ that replaces match offsets with indexes of match offsets. It yields a more compact output at the cost of an extra indirection (hence slower decoding speeds).
ROLZX: Extended ROLZ with more match searches and a more compact encoding.
SRT: Sorted Rank Transform: A transform that that reduces entropy by assigning shorter symbols based on symbol frequency ranks. Usually used post BWT.
LZP: Lempel Ziv Prediction can be described as an LZ implementation with only one possible match (hence the offset is not even emitted). It is pretty weak (but fast) and usually used prior to a BWT to remove some redundancy and speed up coding.
MM: Mutimedia transform is a fast transform that removes redundancy in correlated channels in some multimedia files (EG. wav, pnm).
UTF: a fast transform replacing UTF-8 codewords with aliases based on frequencies.
PACK: a fast transform replacing unused symbols with aliases based on frequencies.

Entropy codecs.
Several entropy codecs have been implemented (sorted by increasing compression):
Huffman: The codec is a fast canonical Huffman implementation. Both encoder and decoder use tables to compute code lengths and values instead of a tree (for speed purpose).
RANGE: A fast implementation that uses pre-computed block statistics.
ANS: Based on Range Asymmetric Numeral Systems by Jarek Duda (specifically an implementation by Fabian Giesen). Works in a similar fashion to the Range encoder but uses only 1 state (instead of bottom and range) and does encoding in reverse byte order.
FPAQ: A binary arithmetic codec based on FPAQ1 by Matt Mahoney. Uses a simple, adaptive order 0 predictor based on frequencies. Fast and compact code.
CM: A binary arithmetic codec derived from BCM by Ilya Muravyov. Uses context mixing of counters to generate a prediction. Efficient and decently fast.
TPAQ: A binary arithmetic codec based initially on Tangelo 2.4 (itself derived from FPAQ8). Uses context mixing of predictions produced by one layer neural networks. The initial code has been heavily tuned to improve compression ratio and speed. Slowest but usually best compression ratio.

Compression levels:
0 = NONE&NONE (store)
1 = PACK+LZ&NONE
2 = PACK+LZ&HUFFMAN
3 = TEXT+UTF+PACK+MM+LZX&HUFFMAN
4 = TEXT+UTF+EXE+PACK+MM+ROLZ&NONE
5 = TEXT+UTF+BWT+RANK+ZRLT&ANS0
6 = TEXT+UTF+BWT+SRT+ZRLT&FPAQ
7 = LZP+TEXT+UTF+BWT+LZP&CM
8 = EXE+RLT+TEXT+UTF&TPAQ
9 = EXE+RLT+TEXT+UTF&TPAQX

———————————————————————-

Run only 1 active instance of the program!

Current file has its own status in the list: «running», «done» and «saved space».
Full stats:
1. Number of compressed files (total and current session).
2. Files in the queue (quantity).
3. Saved disk space (Mb) total and for each file in the list.
(You need to save files «res\size.txt» and «res\numbers.txt» before updating, if you want to save the overall statistics («Total»)).

You can specify the path to the file «bsc.exe» and «Kanzi64.exe» manually in a separate form.

Please send any bugs and requests to maxcompress@ya.ru whith subject “Ultra Compression Params Generator”.

It’ free for commercial and non-commercial use!

If you like my program and you want help improve it, you can help me (donate) here.

Icon made by Swifticons from Flaticon:
https://www.flaticon.com/authors/swifticons

Disclaimer: use at your own risk. Always keep a copy of your original files!

History:
2024-11-25
Ultra Compression Params Generator 1.02
-new options for Kanzi:
-added smart modes to select the best compression options (based on prepared tests)
-max number of transforms has been increased to 5
-added option with unpacking time limit (for fast decompression)
-added option “select all” for transforms
-added fast modes for tests

2024-05-05 – 1.01
– first release

Download Ultra Compression Params Generator 1.02 (8 Mb):
Download here (8 mb)
Mirror 1
Mirror 2
Mirror 3

The post Ultra Compression Params Generator 1.02 first appeared on Super Compression - useful programs/tools and information!.

Features:
– High compression ratio (20% smaller).
– Supported formats: jpg, jpeg, jpe.
– Lossless compression.
– You can set «Run in background (without console output)» or uncheck it for manual process control.

Compression:
– Lossless JPEG transcoding: about 20% smaller.

Features:
– Best lossless image compression.
– Progressive decoding.
– Lossless JPEG transcoding.
– Designed for both photographic and synthetic images.
– Fast software encoding and decoding.
– Full support for wide gamut and HDR.
– Perceptually optimizing reference encoder.
– FOSS and royalty-free.

Compression modes:
– Add to archive.
– Extract from archive.
– Convert to PNG.

JPEG XL uses a novel internal color space (called XYB) for high-fidelity, perceptually optimized image encoding, but it can also handle the simple YCbCr color transformation applied by JPEG.

JPEG XL offers significantly better image quality and compression ratios than legacy JPEG, plus a shorter specification. It is designed for computationally efficient encoding and decoding using software implementations without the need for additional hardware acceleration, even on mobile devices.

The following people made key contributions to the JPEG XL project: Jon Sneyers, Jyrki Alakuijala, Lode Vandevenne, Luca Versari, Jan Wassenberg.

The JPEG Committee plans to submit the JPEG XL standard as a Final Draft International Standard (FDIS) in January 2021. If approved, ISO and IEC will publish it as an International Standard in July 2021.

Run only 1 active instance of the program!

Current file has its own status in the list: «running», «done» and «saved space».
Full stats:
1. Number of optimized files (total and current session).
2. Files in the queue (quantity).
3. Saved disk space (Mb) total and for each file in the list.
(You need to save files «res\size.txt» and «res\numbers.txt» before updating, if you want to save the overall statistics («Total»)).

You can specify the path to the file «cjxl.exe» manually in a separate form.

Program uses ImageMagick for pre-convert of input files and as viewer for JXL files. ImageMagick supports jxl since version 7.0.10-54.

Please send any bugs and requests to maxcompress@ya.ru whith subject “Ultra7z JPEG Archiver”

It’ free for commercial and non-commercial use!

More info about JPEG XL here

If you like my program and you want help improve it, you can help me (donate) here.

Icon made by Freepik from Flaticon.com
https://www.flaticon.com/authors/freepik

History:
2022-06-26 – 1.01
– first release.

Download Ultra7z JPEG Archiver 1.01 (English) (34 Mb):
Download here (34 Mb)
Mirror 1
Mirror 2
Mirror 3

The post Ultra7z JPEG Archiver 1.01 first appeared on Super Compression - useful programs/tools and information!.