It's an interesting comparison, the ARM with the electric motor - the "fractional horsepower" electric motor was revolutionary in its time. Instead of running a shaft down the length of a building and taking power off with belts and pulleys, you could have a motor where it was needed. And then domestically we got refrigerators, and washing machines, and vacuum cleaners, and sewing machines.

There are horses for courses.
ARM-based systems typically don't have the raw horsepower of x86 ones, but I think that's mainly because ARMs are usually put into environments where low power usage is desired, and that's the tradeoff you have to make. x86s are more commonly used in desktops because of the head start they got with IBM using 'em.
The market x86 was already in moved towards higher performance, with power consumption being secondary(if it was a consideration at all), whereas the market ARM found itself in values low power consumption somewhat more than sheer performance.

Not only low power consumption but small area on the die. It's almost absurdly common to include a basic ARM core (a Cortex-M0+ has about as many gates as an early ARM from the 1980s), as a cheap and convenient way to add intelligence to a control circuit without the hassle of designing specialised hard logic. It's much easier to find tolerably competent embedded software engineers than excellent hardware engineers.

So your Ethernet chipset has an ARM core in it. The security coprocessor built into your CPU is itself a self-contained ARM computer. Your fancy GPU, capable of herculean feats of computational prowess, probably delegates basic 2D and text graphics work to an ARM core embedded within it. Your expensive SSD is a bunch of dumb NAND Flash chips hooked up to a reasonably powerful, multi-core ARM controller. Many cheap sensor chips are actually ARM microcontrollers in disguise. Your microwave, washing machine, and Internet router have ARM CPUs inside.

Your mobile phone might have as many as a dozen ARM cores in it. To quote the old 3dfx ads, "it's kind of ridiculous".

Was there any other kinds CPU today can have better horsepower then x86? Power9? check the AMD's new 64-core EPYC.

Given the same level of investment and focus on performance, the PowerPC architecture could certainly have reached today's AMD64 performance levels. It has certain definite architectural advantages over x86, having been designed from the outset for high performance and design scalability.

But arguably, some of the best-performing alternative CPUs are also being made by AMD. They're sold under the brand name "Radeon"…

Actually nvida's quadro and tesla are better
but.. they are not "CPU"
like a high-speed train are not a car,
even they are electric

Radeon is presently built around a publicly documented ISA: GCN. It is Turing complete and supports running programs of arbitrary length. It supports multitasking and memory mapping.

In short, it is every bit as valid a CPU as the humble 6502 is. It's just vastly more capable.

yeah but its an "cpu" solder on a PCIe card use to drive monitor

yeah but its an "cpu" solder on a PCIe card use to drive monitor And people call it a videocard

It's also available paired on the same die as x86 cores, inserted into a m/board that doesn't support integrated graphics. In that case it can still be used for computation and, with an application suited to the design, is faster than using the x86 cores.

ok, i got it, no need more talks on radeon.

There has been a number of ARM server cpus which are based on ARMv8. I think this is the latest: https://fuse.wikichip.org/news/1663/ampere-ships-first-gen-arm-server-processors/

They have all been running Ubuntu or some Linux variant OS. Mainboards have been expensive, so market penetration quite poor. Amperes 3.3GHz at $850 (32 cores) shows that its still not your average portable, but gaining on x86 workstations. If you pair it with this $550 mainboard, its almost competitive: https://www.solid-run.com/nxp-lx2160a-family/honeycomb-workstation/

A few thoughts on this area...

First, I think it's very much the exception that x86 has had the life it has. Most CPUs are replaced by something incompatible, which usually does much better or much worse in the market. Moto did pretty well, in fact, with 6809 and then 68000. But 68000 was not an endpoint: 88000 and powerpc came after, IIRC. And these are not nearly so compatible as the x86 line - compatibility was not a goal. Zilog tried similarly but got very little traction with their successor ideas, the not-z80-compatible Z8000 and the Z8000-compatible Z80000.

Second, Intel tried several times to do the normal thing, to kill x86 and make a successor. But it was too much of a monster. I can think of i432/8800, i960, i860, Itanium.

So, if 6502 had had an owner interested in higher performance implementations and architectural extensions, we might have seen different developments - but it still would have been unusual. Both Commodore and Atari, in rather different ways, went to 68000 for their successor lines. Apple dallied with '816 but again went to 68000 (and ARM, and PowerPC, but that's all later.) Acorn dallied with '816, tried National Semiconductor's 32000 line, and then made ARM. That's interesting, because it was a move which said a new architecture was a better way to proceed than an improved implementation: nothing would have prevented Acorn from trying to make an improved 6502, but they judged that a simple pipelined machine with a wide memory interface and regular instructions was the way to go.

Finally, of interest in this discussion, a mid-'85 project idea within Apple which didn't fly but could be compared to Acorn's idea:

Pete Foley's RISCy 6502ish implementation for Apple

A note on the PowerPC: it was originally developed by the AIM Alliance - that is, Apple, IBM, Motorola.

It was a direct derivative (though not 100% backwards compatible) of IBM's RS/6000 POWER architecture, the name essentially expanding to "Performance Optimised With Enhanced Reduced Instruction Set Computing for Personal Computers". Motorola's contribution was the external bus architecture originally intended for the 88k. Apple, at the very least, served as the launch customer, though I'm sure they also had some technical input. The first product was the PowerPC 601, a hybrid CPU that retained backwards-compatible POWER instructions, which were dropped from later models.

Because both the 68K and PowerPC were big-endian, it was relatively straightforward to write an emulation layer that allowed existing 68K Mac software - including, initially, much of the operating system! - to run on the new PowerMacs, often actually faster than on a native 68K CPU. That allowed Apple to legitimately claim a high degree of backwards compatibility, despite the two CPU architectures being very different. The fact that an 80MHz PowerPC would run native software about 5x the speed of the 40MHz 68040 (from just the previous year) showed clearly the advantage of migrating.

The unique circumstance of the x86 is that no alternative with such a big advantage-to-cost ratio appeared to replace it. For a long time, RISC CPUs held a commanding performance advantage over contemporary x86, but nobody stepped up to create the necessary emulation layers that would accommodate the huge and varied library of legacy PC software. Microsoft did port Windows NT to some of these alternatives, but with no application software to run on them, customers stayed away in droves.

Instead, the x86 itself was developed to meet emerging performance needs. The K5, K6 and P6 cores showed that translating CISC instructions to execute on a RISC backend core could at least approach the required performance. Heated competition between the x86 licensees (chiefly AMD and Intel) and continued demand for high performance from consumers kept the R&D teams well funded and motivated. The rest is history.

But if that leap from pure CISC pipelines (as in the Pentium) to the hybrid architecture had not occurred, I'm confident that the IBM PC clone ecosystem would eventually have collapsed. Perhaps new competitors to Apple would have arisen, using ARM, MIPS and/or Alpha CPUs. We will never know for sure.

A bit of a digression, but oddly enough your mention of Alpha reminds me of another thought I had: we had SPARC, MIPS, and ARM, and with rather different outcomes, but I don't have any thought-out thoughts as to why.

Another point to the original question: it's notable that both 8008 and 8080 were already bigger chips (in transistor count) than 6502, and also notable that the 8086, the first in the x86 line, was not binary compatible but only source compatible. And, the architect of 8086 has said that it was a more software-centric architecture than previously. So, perhaps for the 6502 to have had such a successful future, it would have needed a break with compatibility: more like the 6809 was to the 6800, than the 816 was to the 02. Except, a bit more like the 68000 than the 6809... high level languages were coming, and a cheap-as-possible micro was going to be handicapped.