Why do Android phones have such powerful hardware compared to iPhones? Does Android need that hardware to run correctly?

Some reasons high-end Android phones have higher specs than the iPhone: Because the OEM can. While it is possible to stuff Android into lower-end phones, this leads to poor performance which ruins the reputation of Android. Android apps can run fully in the background, except the UI. The iPhone apps can't, and can therefore use less CPU overall. Background app services use memory. Android uses the virtual machine, while run native code. This uses up more memory. The Android team made a long bet that VM technology will catch up. It is only recently that it has, plus advances due to .

There are two main reasons, and others that would take too long to describe. 1. a Smartphone is not a PC. Even a MacBook, specially the Air and the new MacBook are not PCs, in the sense of the crazy wave of bigger boxes, bigger CPUs, liquid refrigeration, power adapters with multi hundreds of watts. A SmartPhone, like a laptop, is a device that aims at focus on battery longevity first, and performance second. It's worthless to be able to do an operation in a shorter time if then the battery is gone. So Apple instead of trying to jam inside the latest fastest hungriest V8 muscle engines, err, quad cores and (fake) octa-cores and a lot of hungry memory, instead they keep the hardware as fast as possible but up to the most efficient level, and then further optimise it, both the hardware and the software. Think of it like a BMW 320 (or 330) vs. an M3. Sure the M3 is an amazing machine, but I wouldn't want or need one to carry my family and to last 900km/600miles to the tank. Or have a Bugatti and then replace the tires every 30 miles or kilometres or whatever. 2. the Apple OS is being optimised for about 30 years. When Steve Jobs created NeXT, they've picked some of the best parts of Unix, added a proper graphical engine on top, and during these 30 years they've been focusing both on new features, but continuously on optimisations. OS X is still typical to have one version with new features and the next with optimisations. It was this "this version is just optimisations so we'll offer it for free" that triggered OSX being free since then. iOS is the same. iOS7 got some huge under-the-hood graphical changes that made the OS consume much more memory and put the 512MB devices - 4, 4S and iPad 2 - under a lot of pressure (pun intended), but since then iOS8 and iOS9 have been continuously been optimised to make those work better. Having full control of all components - hardware, kernel and OS on top - as well as limiting the hardware to only a limited number of hardware combinations also allows them to fully optimise each step. Android on the other hand is a much newer OS, based on the Linux Kernel that is great but not perfect for a limited device (let me be straight here, the problem is not the kernel per se, but the quality of the "hardware drivers", which are usually outside the Kernel's (quality) control. Then because it's based on Java (which is not a huge problem per se), there were some technical decisions that were not the best. (Apple also makes some mistakes on their APIs, but they are much more agile on convincing developers to move forward and deprecate the old stuff - Mac OS to OSX, PowerPC to Intel, Carbon to Cocoa, Objective-C to Swift). For example, on iOS when capturing a video frame for post-processing and either apply live effects or encode as a video, iOS has a direct memory access mechanism where the camera will save the frame into that memory, the app can access and manipulate that memory block directly, and then dispatch it to the screen or to the hardware encoder, all without a single memory copy around. Android can't do this, and has to constantly copy memory around, at minimum to wrap the internal memory into a Java byte[]. I'm sure this is not a technical limitation but a bad design decision because Java does support DirectByteBuffers and if the frame would have been defined as an API call passing the ByteBuffer, the same performance and behaviour would be possible on Android. Until recently there was also the difference that iOS compiles into native code, whilst Android compiles into an intermediate byte code (JVM), and then the device knows how to run that byte code. This has the disadvantage that code is only "compiled into native" when on the device, but also has the advantage that only relevant code needs to be compiled into native, and inlined, and optimised during runtime. Fortunately Google understood that this advantage on VM languages, specially Java, are only worth when the code runs for longer periods, as the initial "slow byte code running" will be compensated by the dynamically analysts of the running code, their hotspots and the compilation of what needs to be optimised. On a mobile device, the apps won't run enough time to get this optimisation, and it's overkill to do this whole analysts every time an app runs. So recently Google switched to a different VM philosophy where the byte code is compiled into native code the first time the app runs (or when it's installed?), so the overhead is done only once, and then the app will have a consistent performance. Another drawback of using Java is that the typical Garbage Collectors are only efficient if the memory usage is kept below 75%, so it has 25% available for management and cleanup. This is one of the reasons why Android devices need more memory than iPhones (why 512M iPhones - until 4S - had 1G androids, then 1G iPhones had 2G androids - until the 6 - and now that the 6S has 2G, Androids are at 3 and, who knows, may be even trying to jam 4GB). But then the biggest problem with this Garbage Collector overhead is not even itself - it's great to develop code without the need to manually manage memory - but it's the unpredictability of resource allocation. With manual memory management, a developer knows there will be a tiny delay at a certain point of the code. With Garbage Collector, the delay may occur at any point in time. The GC may just need to occupy part of the CPU to cleanup, but may also need to freeze the system to perform some memory shuffling around. This "world stop" is just a some milliseconds, but it's enough for a user to notice a scroll being jumpy, or a tiny stop on a game.

Yes, this is true for Android Devices. As you know iPhone has less than 1 GB of RAM but is still capable of running applications much faster. The main reason behind this is that Android lacks in memory Management. With softwares like Opera Mini or Google Chrome, it uses more than 20 % RAM. Apple focuses on its hardware compatibility and phone performance but Android does not. As a result, carriers and manufacturers screw up Android performance.