I have an old weak laptop (core duo at 1.7Ghz) and a quad core phone(arm cortex a7). Both are running linux.

Could I use phone's resources from laptop to execute(process) stuff for laptop? Is there such a program for that?

Is this not possible because of laptop using x86 architecture, and phone using ARM? Now, I don't think that's true cause I've read people are installing non-android stuff on their rooted android phones, like the LAMP stack, or other programs built for linux.

What do you guys think about all this, do you think it's stupid? Cause it might be. I tried Googling but I've only found some rubbish.

If you have an idea of how it can be done, please write it here as well. For instance, I'd like to run Chrome for desktops using my phone's resources. Now, I'd be fine with just using the phone's CPU, it doesn't have to use phone's RAM as well. Is that even possible, using CPU on one computer, and RAM/storage on another? I'd say it is, way API of some kind, so the process running on phone CPU doesn't even know it's accessing RAM on another machine. The obvious bottleneck is network connection speed, which in this case is WiFi(since phones don't have wired LAN obviously). I'm personally using the G standard, but IMO the ac standard would virtually resolve this bottleneck issue as it can push almost 2 gigabits per second.

I don't know guys. What do you think?

  • If you have ssh and a working X server on your phone, you can ssh -X and run any program you'd like on your phone while seeing the results on your laptop. That being said, the X protocol over a slow network can be a bit frustratingly slow...
    – user43791
    May 25, 2015 at 23:17
  • @user43791 on iOS at least you can use a USB as a tcp relay thing. From what little I've read, this apparently is possible on android via ADB.
    – Wyatt Ward
    May 25, 2015 at 23:56

2 Answers 2


Ignoring the fact that your core duo is better than your phone, it may be possible to forward X11 over USB between them (see this wiki for an iOS example that might still be relevant), and install qemu and binfmt on the phone to (SLOWLY) emulate chrome. Otherwise, if you have the knowledge and a lot of time on your hands, you may be able to port desktop chrome to your phone. For this to be even slightly feasible, you would want to have a desktop-style (read: not android) linux, because you'd want to have access to resources like X11 and because you have to use Java for interfaces on android phones.

It may be possible, but I would consider it totally unworth the effort. I am running a core 2 duo right now, and while it is 64 bit unlike yours, it has 2GB of RAM and can run things just fine. Let your phone be a phone if you value your sanity.

For smaller applications, like command-line based programs, I have successfully done this. Only in my case I cross-compiled the program in question using this toolchain. The program was an interactive fiction interpreter called git, not to be confused with the version managing system. I used tcprelay (described on the wiki page) to ssh into my iphone over USB and ran my game through it. But it really is not worth it, and the USB would be a bottleneck anyway.

  • Awesome response, put me on the right direction. Thank you.
    – The Onin
    May 26, 2015 at 1:22
  • glad I could help :)
    – Wyatt Ward
    May 29, 2015 at 8:44

Parallelization is difficult. Automatic parallelization is a research topic, and nowhere close to being solved — apart from embarrassingly parallel problems (yes, that's the technical term), parallelizing is pretty much requires human guidance and is difficult even with human guidance. The reason parallelizing is difficult is that dispatching a task to another processor adds a lot of overhead, and the processors end up spending a lot of time waiting for the others to free a resource that they need or respond to a query. Parallel execution is only worthwhile if the gain in total time from parallel execution is more than the overhead of synchronization. What this means for you is that there's no magic way to split a task between two computers, you'll have to decide what programs to run on which computer.

A program can't use the phone's CPU and the PC's RAM. It doesn't work that way, any more than you can use the wheel in one car to steer the axles in another car. It either runs on one computer or on the other computer. (You could abstract RAM as an API, but it would be extremely slow — milliseconds instead of nanoseconds.)

You can run a program on the phone and interact with it on the PC or vice versa. In other words, you can split the running of the program from where its interface is hosted. Several mechanisms exist for that, including:

  • ADB over USB
  • SSH over a network connection (you can install a client, a server or both on the phone)
  • X11 forwarding over SSH for GUI programs

You would not run the same binaries on the phone and on the PC, since they have different processor architectures. Almost all Linux software can run on any supported processor architecture, but they are compiled differently. When people install software like Apache on their phone with an ARM processor, they're installing an ARM binary. Many PC distributions have an ARM version (or several) in addition to the 32-bit and 64-bit PC versions, for example Debian stable currently supports 10 processor architecture including i386 (the one for your PC) and armhf (the one for your phone).

You can run a PC binary on an emulator in your phone or vice versa. For example, Google's Android emulator is based on QEMU, in which QEMU is used to emulate an ARM processor; QEMU can also emulate an x86 processor and run on an ARM processor. But emulation would be pointless in your case, because it is significantly slower than running a native binary.

Your computer and your phone have clock frequencies in the same ballpark. Clock frequencies can't be compared across processor architectures, not even across processor designs with the same instruction set, because the design of the processor determines how many clock cycles each instruction takes. Which one is the fastest will depend on the task, but they're in the same ballpark. Few tasks can be parallelized in a way that benefit from having 4 CPUs, so this number isn't relevant for most tasks. Given the overhead of offloading the data from one machine to another, offloading computation on your phone would only be useful for a task that's massively parallel and that your phone's processor is faster at than your PC's processor. For such parallel tasks, offloading to your GPU might be a better bet (GPUs are good at parallel computation, but bad at memory accesses).

  • He has a core duo, not an i7. However, this is a very good answer! I'd add something about qemu to the part about architectures. I have made my computer run android ARM binaries with qemu and binfmt. Also, you don't want amd64 on a core duo - the core duo (without the '2') is 32 bit i386.
    – Wyatt Ward
    May 29, 2015 at 8:48
  • 1
    @Wyatt8740 Ah, thanks, I don't know what made me look up i7 (maybe cross-contamination with A7). I've added a mention of QEMU, just to say that it's irrelevant here where the objective is performance. May 29, 2015 at 13:43
  • true enough about the performance. :P
    – Wyatt Ward
    Jun 1, 2015 at 4:52

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .