What does HackerNews think of par2cmdline?

Official repo for par2cmdline and libpar2

Language: C++

I seen this mentioned a few times in the thread. While true, there are other tools (with more control) for creating recovery data, notably, parchive[1].

[1] https://github.com/Parchive/par2cmdline

Parchive development has moved GitHub.

PAR2 (libpar2/par2cmdline) continues to see active (if sporadic) maintenance. The most recent tagged release was 2020-02-09 but there've been a handful of PR's merged since. [2]

PAR3 has a reference implementation and alpha spec (libpar3/par3cmdline) which is based around Blake3. [3]

OG PAR (libpar/parcmdline) is legit unmaintained; the last release was 21 years ago. [1]

[2]: https://github.com/Parchive/par2cmdline

[3]: https://github.com/Parchive/par3cmdline

[1]: https://github.com/Parchive/parcmdline/

If one were to bring back punch cards that are somehow updated or more advanced to hold more data then please for the love of sanity first make a machine that you can drop a massive stack of them into that will sort them. Or make it so that the reader can read them out of order and add parity data so you can lose a few cards or have a few coffee soaked unreadable cards. something along the lines of par2 [1]

[1] - https://github.com/Parchive/par2cmdline

It may not exactly be what you are looking for, but if you want to protect a stable data set from bit-rot after it's been created, make sure to take a look at Parchive/par2:

https://en.wikipedia.org/wiki/Parchive

https://github.com/Parchive/par2cmdline/

> or maybe like Parchive

par2 even has options for specifying level of redundancy. I've had good experience in recovering large corrupted files from an external drive - since then, I've incorporated it into the automated backups of my personal infrastructure.

https://github.com/Parchive/par2cmdline

Thanks for the article and code.

Also check out https://github.com/Parchive/par2cmdline

I wish something like this was integrated into a modern and free archive format. RAR has it. RAR also got volume recovery: when creating split multi-volume archives you can also create recovery volumes - each recovery volume can replace any other one missing volume. It was a life-saver in floppy-disk times.

> One thing which concerns me is the integrity of my files. It's no good backing them up if they become corrupt without me knowing. Most of my files like photos, old emails, etc will never change and I want to keep it that way.

Look into par2 files (https://github.com/Parchive/par2cmdline).

Arrange your 'backup data' in some logical way, then generate par2 files for logical "groups" (i.e, per directory containing a set of files, etc.) with an amount of 'redundancy' you feel comfortable with.

You can then periodically run par2 scans of the static backups to both detect changes, and to repair the changes (provided the changes are not larger than the amount of redundancy you originally requested).

When I record to DVDs, I always add error correction using dvdisaster.[1]

In addition, I sometimes have par2 files[2] on the DVD as well, though it's probably better to just have additional dvdisaster ECC instead.

It's a good idea to periodically go through all your old backups and transfer them to new media, or at least make sure the old media still works and start recovery on them right away if they don't.

[1] - http://dvdisaster.net/

[2] - https://github.com/Parchive/par2cmdline

Alternatives or additions:

* Store par2 parity information alongside your cloud storage and/or NAS: https://github.com/Parchive/par2cmdline

* Use a file system with strong data checks and repairability, basically meaning, ZFS with a sufficient redundant set up. "zpool scrub" can do wonders, and you can guarantee backups to a different pool are identical to the source.

When I use xz for archival purposes I always use par2[1] to provide redundancy and recoverability in case of errors.

When I burn data (including xz archives) on to DVD for archival storage, I use dvdisaster[2] for the same purpose.

I've tested both by damaging archives and scratching DVDs, and these tools work great for recovery. The amount of redundancy (with a tradeoff for space) is also tuneable for both.

[1] - https://github.com/Parchive/par2cmdline

[2] - http://dvdisaster.net/

There's a par2 "fork" under active development - https://github.com/Parchive/par2cmdline

The fork compiled for me this week, when the official 0.3 version on Sourceforge wouldn't. I vaguely remembered par3 being discussed, but couldn't find anything usable. And that's an example of why to be wary of new formats, I guess?

par2 is another alternative for redundant copies: https://github.com/Parchive/par2cmdline

It's kind of like RAID for data, and removes the uncertainty that maybe ddrescue wouldn't get an I/O error and just receive and save bad data (it happens). It'd also be capable of repairing damage, up to the redundancy level par2 archives are created at (default is 5%, can go all the way to 100% -- which would mean you don't need any of the original data assuming all par2 files are not corrupt either (which it can also handle...)).

That's certainly an interesting read but if I really care about something I'll usually generate PAR files. At that point, does it really matter what archiver I'm using at the time or should I still be worried?

https://github.com/Parchive/par2cmdline

The time for complaining about xz has well and truly passed. One might infer that the problems with xz are related to the attitude of other developers...

But I dogress. When you create archival packups you use must use error correcting systems. Par is a good place to start. https://multipar.eu/ https://github.com/Parchive/par2cmdline

There is this par2cmdline[1] tool which is (as the name suggests) a console program "for creating and using PAR2[2] files to detect damage in data files and repair them if necessary". GPar2[3] (alpha) is a simple GTK+ GUI for it.

[1] - https://github.com/Parchive/par2cmdline

[2] - https://en.wikipedia.org/wiki/Parchive

[3] - https://github.com/Parchive/gpar2