By old Mac hardware I assume you mean x86-64 Intel Macs? Pretty much any modern distro should work on that.

If you are in general ok with tinkering a bit with your computer, I'd recommend Arch derivatives like EndeavourOS or CachyOS, these come with full GUI installers and software availability on Arch is one of the widest around.

Arch is rolling release, though, meaning each package gets updated as soon as a new version is available, rarely it leads to things breaking.

If you want something more stable, Fedora is a great choice, too.

As you mentioned yourself, Mint also exists. It's packages are usually on the older side, but the distro itself is trying to be this "gateway drug of Linux".

The feel of the system is mostly determined not by your distribution, though, but rather by your desktop environment. As far as I know, GNOME is the most "Mac-like" out of popular ones. KDE is "Windows done right", and there are a lot of other options, but you'll mostly have to try them out yourself until you find something you like.

Why did you have to point it out? I didn't even notice until you did!

I must ask you to read the community description, especially if you never read it before.

I have a love/hate relationship with a lack of a comma somewhere around "old" in your message.

bash cat

You upvote because you are horny, I upvote because there is a funny joke. We are not the same.

BitTorrent breaks your data in blocks, each block is hashed, their sizes are known. Assuming you got your .torrent file from a legitimate source, it's practically impossible to receive something else, as long as your client does all the checks properly.

In theory, it is possible to write malware that will collide hashes with some other content, but considering you are restricted to the size of the actual content, it's extremely unlikely that out of all the millions of .torrents we created so far we can find even one for which it is possible.

And even if you win this absolutely bizzare lottery, you'll be competing with legitimate peers for serving the blocks. If at least one block that you care about is not served by you, the recepient will just get corrupted content that won't be dangerous in any way. In other words, you need to have so much bandwidth, that you serve everything before anyone else can serve even one significant block. At which point you will probably have to spend a lot more money on that than you'll ever get from whatever malware you are trying to serve.

I gladly present you this jank.

You might need these to compile:

cargo add image
cargo add clap --features derive

And the jank itself:

use std::path::PathBuf;

use clap::Parser;
use image::{ imageops::{self, FilterType}, ImageReader };

#[derive(Parser)]
struct Cli {
    path: PathBuf,
    #[arg(short = 'H', long, default_value_t = 30)]
    height: u32,
    #[arg(short, long, default_value_t = 0.4)]
    ratio: f32,
    #[arg(short, long, default_value_t, value_enum)]
    filter: Filter,
}

#[derive(clap::ValueEnum, Clone, Default)]
enum Filter {
    Nearest,
    Triangle,
    Gaussian,
    CatmullRom,
    #[default]
    Lanczos3,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args = Cli::parse();
    let filter = match args.filter {
        Filter::Nearest    => { FilterType::Nearest },
        Filter::Triangle   => { FilterType::Triangle },
        Filter::CatmullRom => { FilterType::CatmullRom },
        Filter::Gaussian   => { FilterType::Gaussian },
        Filter::Lanczos3   => { FilterType::Lanczos3 },
    };
    let img = ImageReader::open(args.path)?.decode()?;
    let original_ratio = img.width() as f32 / img.height() as f32;
    let width = ( args.height as f32 / args.ratio ) * original_ratio;
    let out = imageops::resize(&img, width as u32, args.height * 2, filter);
    let mut iter = out.enumerate_rows();
    while let Some((_, top)) = iter.next() {
        let (_, bottom) = iter.next().unwrap();
        top.zip(bottom)
            .for_each(|((_, _, t), (_, _, b))| {
                print!("\x1B[38;2;{};{};{};48;2;{};{};{}m\u{2584}", b[0], b[1], b[2], t[0], t[1], t[2])
            });
        println!("\x1B[0m");
    }
    Ok(())
}

Some of this is totally on Google Translate.

In the second picture, the text is 飯テロ見ながら、寝るよ

飯テロ is not "terrorist attacks". 飯 is food, テロ is terrorism, together they form a slang word that is used when someone posts pictures of delicious food while you are hungry.

So, this person was just going to watch food porn while lying in bed, but... Yea, translation error.

Looks like a perfectly normal "Enter" key on an ANSI keyboard. Why the confusion?

Try MusicBrainz Picard. I've had good experience with their recognition quality.

Some people have to use their stuff for a variety of reasons, don't be a dick about it.