The “why” doesn’t matter. If you don’t like it, change the shortcuts on your own machine. That’s the beauty of Linux.

I read a lot of answers online that its a bad idea, but the arguments did not make a lot of sense.

If you want to understand, look for original reason, not for answers to your own little questions.

The thing about “it’s a heavily ingrained part of the eco system” is that, it really is. We’re not talking about user habits here, we’re talking the whole ecosystem of software that expects it to work that way: the kernel, the shells, SSH, the terminal emulators, the virtual consoles.

Under the hood, those aren’t keyboard shortcuts, they’re control characters and you make those with Ctrl plus a key, and it’s handled by the kernel itself so you’d have to run a custom kernel on every machine you use just so you can use Ctrl+C for copy.

So, on the wire those have to stay. You can configure your terminal emulator to maybe swap Ctrl and Super as super doesn’t mean anything for a terminal. That’s pretty much how things happen to be on macOS, since copy/paste is Super+C/V. Then your Ctrl key is free for anything you might want.

Some extra docs about all the codes: it’s far from just ^C: https://man7.org/linux/man-pages/man4/console_codes.4.html

It is a bad idea to get used to using Ctrl+C as copy on the terminal because then you will accidentally abort programs all over with muscle memory on systems you haven’t twisted beyond recognition customized.

Just do it. It’s your computer.

matching other programs and platforms

Actually, Ctrl+C is the interrupt hotkey for pretty much every CLI app/terminal on every platform. Try it within the Command Prompt/PowerShell/Windows Terminal, or the macOS terminal - they’ll all behave the same.

The use of Ctrl+C as an interrupt/termination signal has a very long history even predating the old UNIX days and DEC - it goes back to the days of early telecommunications, where control characters were used for controlling the follow of data through telecommunication lines. These control characters, along with regular characters, were transmitted by being encoded in binary, and this encoding scheme was defined by ASCII (American Stanard Code for Information Interchange), published in 1963.

In ASCII, the control character ETX (meaning end-of-text; represented by the hex code 0x03) was used to indicate “this segment of input is over”, or “stop the current processing”.

Now what does all this have to do with with Ctrl+C you ask?

For that, you’ll need to go back to the days of early keyboards. Keyboards back then generated ASCII codes directly, and when a modifier key (Ctrl/Shift/Meta) on a keyboard was pressed in combination with another key, it modified the signal sent by the keyboard to produce a control character.

Specifically, pressing Ctrl with a letter key made the keyboard clear (set to zero) the upper three bits of the binary code of the letter, thus effectively mapping the letter keys to control characters (0x00 - 0x1F: the first 32 characters on the ASCII table).

• The ASCII code for ‘C’ is 0x43 (binary 01000011).
• Pressing Ctrl+C clears the upper three bits, resulting in 00000011, which is 0x03 in hex.

And would you look at that, 0x03 is the code which represents the control character ETX.

The use of ETX to interrupt a program in digital computers was first adopted by the TOPS-10 OS, which ran on DEC’s PDP-10 computer, back in the late 60s. It’s successor, TOPS-20 also included it, followed by the RSX-11 (on the PDP-11), and VMS (on the VAX-11).

RSX-11 was a very influential OS, created by a team that included David Cutler. It influenced the design of several OSes that followed, such as VMS and Windows NT. Cutler moved to Microsoft and was the father of Windows NT, and early NT did not include a GUI, so it was natural to adopt existing terminal operation standards, including the use of ETX. In fact, NT’s internals were so similar to VMS that a lawsuit was in the works, but instead, MS agreed to pay off DEC millions of $$$.

Also, when UNIX first came out (1969), it ran on DEC hardware, and so they followed the tradition of using the ETX signal to stop programs. This convention flowed to BSD (1978) which was based on UNIX, and NeXTSTEP (1989), which was based on BSD. NeXTSTEP was developed by NeXT Computers, which was founded by Steve Jobs… and the rest is history.

Therefore, Ctrl+C is something that’s deeply rooted in history. You don’t just simply change something like that. Sure, you may be able to remap the keybindings, but it’s actually hardcoded into many programs so you’ll run into inconsistencies - that is, if you used the standard DE remapping tools built into GNOME/KDE etc.

If you want to truly remap Ctrl+C, you’ll want to do so at a lower level (evdev layer) so that it’s not intercepted by other programs, eg using tools like evremap or keyd. But even then, it’s not guaranteed to work everywhere, for instance, if you’re inside a VM or using a different OS, or in a remote session. So it’s best to remap the keys at the keyboard layer itself, which is possible on many popular mechanical keyboards using customisable firmware like QMK/VIA.

I’ve done it for about a decade without anything bad ever happening.

I have rebound copy and paste to ctrl+c and ctrl+v in konsole and bound the interrupt to ctrl+x using stty intr ^x

Also I keep it consistent across ssh sessions by using Xpipe.

I honestly wasn’t even aware that anybody thought it might be bad for any reason.

Aside from the many decades of history behind the ctrl+c key combo, you may also be interested in an alternative shortcut for copying/pasting that works in every application: ctrl+insert for copy, shift+insert for paste. These combos work in browsers, terminals, text editors, and sometimes even websites that block pasting via ctrl+V.

I often use other signals myself (ctrl+D for closing an input, ctrl+z for backgrounding a process).

Other less used signals that are probably also available: ctrl+\ for SIGQUIT will gracefully terminate some programs (dd), or print diagnostic output in others (ping). ctrl+Q will reset the current line in the terminal. ctrl+R will let you search through your command line history in many Linux shells, and will repaint the screen while a command is running (which is useful when you’re using a TTY and some kind of system log suddenly comes rolling in over your running program’s output). Ctrl+S will pause a program, ctrl+Q will continue execution; this is useful for when you’re looking at commands printing loads of output without having to resort to less/more.

That said, some terminals do bind SIGINT to ctrl+shift+C. Use whatever you prefer, I suppose!

Ask all the people still trying to exit vim.

Because Ctrl c is faster and easier