Running exe on android with network support. QEMU is an emulator for various platforms on a computer. Windows applications on Android – aDOSBox emulator and others

Download Limbo PC Emulator (QEMU x86) APK For Android, APK File Named com.max2idea.android.limbo.main And APP Developer Company Is . Latest Android APK Vesion Limbo PC Emulator (QEMU x86) Is Can Free Download APK Then Install On Android Phone.

Limbo PC Emulator (QEMU x86) APK Description

Limbo is a PC Emulator (x86) based on QEMU. You can now run Debian or DSL Linux on your Android device without root. Ssh, X Server, ftp, vnc, samba, vpn, mysql clients, gcc, java, perl, python right on your Android device. Instructions:http://code.google.com/p/limbo-android/wiki/LimboAndroid* Limbo works only with few Desktop OSes, see below for a compatibility list. * "Hacker"s Keyboard" app (available in Play Store) is highly recommended for use with Limbo. * Emulation speeds are dependent on your device and OS. Limbo works better for devices with DUAL CORE CPUs. ======= ======= COMPATIBLE OSes ============= Instructions and Hard Disk image DOWNLOAD links:http://code.google.com/p/limbo-android/wiki/LimboAndroidCompatible OSes : * Debian Linux x86 - Desktop & Command line * DSL Linux x86 - Desktop & Command line * Trinux - Command line only Other compatible OSes: * TTY Linux * Minix * FreeBSD * AROS(Icaros Desktop): * KolibriOS * FreeVMS * OpenWRT Instructions :http://code.google.com/p/limbo-android/wiki/LimboAndroid=============== THANKS ========== "And so, I captured this fancy, where all that we see, or seem, is but a dream within a dream." - Edgar Allan Poe A Big Thanks to: Fabrice Bellardhttp://bellard.org/and the Qemu teamhttp://qemu. orgglib teamhttp://developer.gnome.org/glibiconv teamhttp://www.gnu.org/software/libiconvandroid-vnc-viewer teamhttp://code.google.com/p/android-vnc-viewerYair Lifshitz (port for x86 phones) =============== FEATURES ========= - CPU - Intel x86/x86_64 - (486,Pentium,Athlon,n270,Phenom) - CDROM disk images - (.iso images read/bootable) - Floopy disk images - (.img raw images read/write/bootable) - IDE hard disk images - (.qcow2 - read/write/bootable) - VGA - (standard, cirrus, VMWare) via VNC local client - Network - User/NAT mode supported only - Load/Save Machine State/Snapshot (Suspend/Resume) * - VNC Remote Connection - Machine/Device Management UI * Saving VM State requires a qcow2 hard disk image, make sure you create one within Limbo. ================ SOURCE CODE ============== This software is released under GPL ver2 license:http://www.gnu. org/licenses/gpl-2.0.htmlSource Code can be found at:https://code.google.com/p/limbo-android/===== TAGS ====== TAGS: OS, Linux, Emulator , PC, x86, virtual, virtual, machine, QEMU, VMWare, virtualbox, Intel, AMD, cpu, network, hdd, cdrom, iso, floppy, image, ssh, tunnel, X11, X Server, X Windows, ftp, samba , vnc, vpn, nmap, gcc, java, perl, python, synaptic, apt-get, package, archive, zip, rar, manager, irc, git, svn, spreadsheet, docs, editing, office, pdf, viewer, DSL , Linux, installer, myDSL, browser, AROS, FreeBSD, Minix, Trinux.

The advantage of virtualization is that it allows you to run several different operating systems on one computer simultaneously, and it does not matter what architecture they are. Among home users, computer emulation programs such as Virtualbox and VMware are often used; these are powerful programs with a graphical interface and many features that are very easy to set up.

But there are other solutions that give more control over the virtualization process and are also more complex. One such tool is qemu. In this manual, we will look at what qemu is and how to use qemu for virtualization, in addition, we will analyze its advantages over other programs.

Qemu is a free and open source tool for emulating and virtualizing operating systems on a computer. The program can run on Windows, Linux, MacOS and even Android. Host resources such as CPU, hard disk, memory are shared among the virtual machines.

Qemu uses hardware virtualization, so it can run guest operating systems almost as fast as on host hardware. The XEN hypervisor or the KVM kernel module on Linux can be used. Qemu can work in two operating modes:

• Full system emulation- in this mode, qemu completely emulates a device, for example, a computer, including all its components, processor and various peripherals. It can be used to run multiple operating systems without rebooting or debugging system code.
• User mode emulation- works only for a Linux host, allows you to run Linux processes compiled for one architecture in another, for example, ARM programs in x86. Useful for development, cross compilation and debugging.

The following architectures can be emulated: x86 (32 and 64 bits), PowerPC (32 and 64 bits), ARM, MIPS (32 bits), Sprac (32 and 64 bits), Alpha, ColdFire (m68k), CRISv2 and MicroBlaze. This list is already more impressive than that of Virtualbox.

Installing qemu

Before we can use the program, we need to install it. If you are using a Linux distribution such as Ubuntu, you can find the program in the official repositories. For Ubuntu the command will look like this:

sudo apt install qemu-kvm qemu

For Fedora and other RedHat systems, you can install the Virtualization group:

sudo dnf install @virtualization

On ArchLinux use Pacman:

For Windows or MacOS, you need to download the executable file from the official website. The program is controlled only through the terminal, so you will not see anything in the main menu of the system after installation. Now let's move on to how to configure qemu.

How to use qemu?

Now that the program is installed and ready to use, let's try to figure out how to launch and use it. But first you need to figure out which commands are used and why. The qemu emulator produces many commands, but they can be divided into groups:

• qemu architecture- emulation of the user's environment for the specified architecture;
• qemu-system-architecture- full system emulation for architecture;
• qemu-img- utility for working with disks;
• qemu-io- a utility for working with disk input/output;
• qemu-user- shell for qemu architecture, allows you to run programs of other architectures on this system;
• qemu-system- a shell for qemu-system-architecture, allows you to completely emulate a system of the desired architecture.

First, we will deal with full system emulation, since the qemu virtual machine is most often used to solve this problem, and only then we will move on to user mode.

1. Using qemu-system

So that you understand what and where it comes from, first let’s look at the options of the qemu-system utility. The command syntax is:

$qemu-system parameters

The syntax for each parameter is much more complicated:

-parameter_name option_name = value : value2

We will consider only the basic parameters and their options that we will need:

• -machine indicates the type of computer that you are going to emulate, you can select ubuntu, pc, pc-q35 and other options, see the -machine help command for more details;
• -cpu- processor type, you can directly transfer the processor type, as well as additional flags;
• -smp- includes simulation of multiprocessor architecture;
• -boot- allows you to configure the boot order of devices, a,b - floppy disk, c - first hard drive, d - CDROM, n-p - boot via network, by default the virtual machine boots from the hard drive;
• -m- indicates the amount of RAM available to the machine;
• -k- default keyboard layout;
• -soundhw- connect the sound card to the system;
• -device- connect the specified device to the machine, you need to specify the driver and its options;
• -name- the name of the guest system will be displayed at the top of the window;
• -uuid- set the UUID for the system;
• -fda, fdb- connect a floppy disk from a file;
• -hda, hdb- connect a hard drive from a file;
• -cdrom- connect an optical drive;
• -usb- enable USB support;
• -usbdevice- connect a USB device;
• -display- select the display type, sdl, curses, gtk, none, vga and others are available;
• -full-screen- run in full screen;
• -no-acpi- disable ACPI support;
• -net- create a network interface;
• -realtime enable real-time mode, the mclock option must be set to on;
• -gdb- wait for the gdb debugger to connect;
• -enable-kvm- enable kvm support;
• -loadvm- load saved state;
• -daemonize- make the process background;
• -snapshot- write changes not to a hard disk file, but to separate files;
• -nographic- disable graphic output.
• -kernel- use the specified linux kernel image.
• -append- command line for the kernel;
• -initrd- initrd file for booting Linux.

We looked at the options for qemu-system-x86-64; for other architectures, they may differ slightly. Now let's look at a few simple examples of how to use qemu, how to create a qemu machine and configure it.

First you need to create a hard drive for installation. You can use real hard drives, but working with images is much more convenient. You can simply create an empty file, padded with zeroes, and then format it to the desired file system during installation, but you can also create a file in qcow2 format, which is the default format in qemu. Let's use the qemu-img command:

qemu-img create -f qcow2 ubuntu.qcow 10G

The -f option specifies the format of the new file. Now we can directly proceed to launching qemu-system. This is what the simplest system startup command will look like:

qemu-system-x86_64 -hda ubuntu.qcow -boot d -cdrom ~/downloads/ubuntu-17.04-server-amd64.iso -m 640

Here we connect our hard drive as hda, then specify that we need to boot from cdrom and connect the ubuntu system image to it. The last parameter specifies how much RAM will be allocated to the machine.

qemu-system-x86_64 -hda ubuntu.img -m 640

Creating a virtual machine with a different architecture is not very difficult, just change the command. For example, let's make a ppc virtual machine:

qemu-system-ppc -hda ubuntu.qcow -boot d -cdrom ~/downloads/ubuntu-17.04-server-amd64.iso -m 640

Since we are not currently using kvm, the system will work very slowly; everything can be greatly speeded up if you enable it using the -enable-kvm option:

qemu-system-x86_64 -hda ubuntu.qcow -m 640 -enable-kvm

By default there will be no sound in the guest system, but you can connect a sound card there:

qemu-system-x86_64 -hda ubuntu.qcow -m 640 -enable-kvm -soundhw ac97

We don’t always run the machine only as a server, sometimes we need to run a regular desktop system, in which case we will have to configure a virtual video card, because what comes by default is only enough for the console. To do this, use the -vga option:

qemu-system-x86_64 -hda ubuntu.qcow -m 640 -enable-kvm -soundhw ac97 -vga qxl

Using the -global qxl-vga.vram_size option, you can set the amount of video memory available to the machine, the value is indicated in bytes, for example:

qemu-system-x86_64 -hda ubuntu.qcow -m 640 -enable-kvm -soundhw ac97 -vga qxl -global qxl-vga.vram_size=4294967

For many machines, it is important that they have access to the Internet. Setting up a qemu network is a fairly broad topic that we will not fully cover in this article. In short, qemu uses a special virtual gateway vlan, which allows you to connect machines to an external network or to each other. Each vlan has its own number. The easiest way to configure a network is to use these parameters:

qemu-system-x86_64 -hda ubuntu.qcow -m 640 -enable-kvm -net nic,vlan=0 -net user,vlan=0

Here we call the -net option twice, the first time we create a virtual network card using the -nic parameter and connect it to vlan number 0. The second -net option creates our vlan 0 with the user configuration type, which does not require additional configuration and automatically connects to the host network.

2. Using environment emulation

Now let's look at using qemu to emulate the architecture in the user's environment. The qemu-user or qemu-architecture command allows you to run programs compiled for another architecture directly on your system. This is very often used for debugging programs compiled for arm on a computer or other similar tasks. The command just needs to pass the command and its parameters.

The news that smartphones are approaching desktop solutions in terms of hardware power has already circled the globe so many times that it puts the blast wave from the Tsar Bomb to shame. The LG V10 has the same amount of RAM as the computer from which I am typing this text. So what, may I ask, should all this portable power be spent on? Of course, for emulation! Not enameling, but emulation, don’t be confused. I have already tried Mupen64, and the experimental version. And now it’s the turn... of the entire operating system!

Of course, I was not the first to follow this logical path of thinking, and at the moment there are several ways to emulate Windows on a smartphone. I will consider each option in turn, and if everything goes well, I will highlight an article for each method that works for me. There aren't many of them at the moment.

QEMU. It is a free and open source program that emulates Intel x86 software. The thing is powerful, cross-platform and very popular in the West. It was not officially ported to Android, and appeared in this article solely due to the work of enthusiasts. However, their enthusiasm did not last long, and support for the ARM port stopped several years ago. Yes, the current version works, and very quickly. There is only one problem - Android 5.0 and higher is not supported, so I won’t be able to test the bare port on my D802.

But I will be able to test other applications, such as Limbo and BOCHS. Limbo is the same as QEMU, but with settings that make it easier to launch and make the program more friendly for an inexperienced user. BOCHS is slightly different in its operating scheme, but uses the same SDL as QEMU, as a result of which it is more stable, although less fast.

Another opportunity to emulate Windows is through the version of DosBox ported to Android. This is the most time-consuming and expensive method in terms of intellectual resources, but it is well suited for games. Let's say you can play Diablo 2 calmly. And DosBox itself, without a mounted OS, is so useful in terms of gaming that it would be necessary to write a separate article on its capabilities.

I will, of course, emulate not relatively recent versions like Windows 7, but the old ones - Windows 95/98/XP. The performance test will consist of actually launching the OS according to the instructions, accessing the Internet, as well as several games, both simple and heavy.

Since I can’t try “naked” QEMU, I will provide instructions so that you can install and run the application yourself. First you will need, in fact, the apk file itself, authored by a person with the nickname mamaich . After installing it, you need to unpack it into the root folder of the device. Next, an sdl.conf file is created in the freshly unpacked folder with the following content:

/sdl -L. -m 16 -boot c -hda 1Gb.img -usb -usbdevice tablet

After this, you need to find the operating system image, rename it 1Gb.img and move it to the SDL folder. Then we turn on the application itself and... pray that everything will start. For full operation, you need a connected mouse and keyboard, but some versions of Windows, built specifically for QEMU, tie part of the rodent's functionality to the volume buttons.

I must admit, for the first time in my life I regretted switching to Android 5. Two years ago, when I needed to run Fallout 2 on the D802, I did it through QEMU. Yes, it took off 10 minutes later, but during that time I had a good walk around the main square of San Francisco. Now QEMU is not available to me, and I don’t plan to roll back to a previous version of Android for the sake of it. I can only hope that BOCHS, Limbo and DosBox will not disappoint me.

Next is a parting word that the unit must have enough RAM. What's left to do? Close the program and go scouring old disks, looking for Fallout 2. We need the image in .img format. It needs to be placed in the SDL folder, in the same place where the Windows image is located. Inside we create a file sdl.conf (if there is none) and write the following inside

/sdl -L. -m 128 -cdrom F2.img -hda w95.img -boot d -usb -usbdevice tablet

Launch QEMU, load Windows 95, one of the discs will contain Fallout 2. And if the stars are favorable to you, you will be able to play. And if you connect a mouse and keyboard, you can play comfortably.

Second way. Homemade, but more reliable

For this method we need to thank the guys from w3bsit3-dns.com who modified QEMU to work with Windows. To start, download the files from the link in the first paragraph. This is our modified libSDL, running separately from QEMU itself. It is configured exclusively in sdl.conf, but supports single and double clicks with the left and right mouse buttons via the volume keys.

In this article I will talk about running applications that were created for PCs running Win on phones and tablets running Android. We will not be talking about updating your gadget to the Windows operating system instead of the Android one. Let's talk about the Win emulator for Android, which can be downloaded at the end of the page, for example, Windows XP or the Windows 7 operating system, and they will work normally (depending on the characteristics of Android) running Android. Today there are 3 Android emulators, but we will talk about the advantages and disadvantages of only two versions of Windows emulators for PC: this is the BOSCHS program and the second option for Android is Sdlaap (QEMU).

You can download the emulator for Windows OS for Android at the end of the text.

But you should understand that none of the options for running PC Windows applications on Android technology will provide all the capabilities that were inherent in a full-fledged Windows OS installed on the user’s PC. If the overall speed of the Android emulator and the possible lack of sound are not so important to you, then you can download the Windows program for Android, where you can then run various programs quite efficiently without access to the network and the Internet. But, for example, you can play toys, especially under DOS, very well. The inability to connect to the Internet is a huge drawback of Android emulators. But for some reason, there is no access to the network from a Windows emulator for Android.

Before you download this Windows for Android, you should understand that, whatever one may say, the minimum RAM, frequency and how many cores the processor has are the most important characteristics of the performance of the Windows emulator. The minimum you need is 512 MB of RAM, at least 500 MB of free memory on the card and a single-core processor with a frequency of 1 GHz. Of course, it will work with slightly lower performance, but only Windows is not older than Win98. OS XP or Win 7 is unlikely to run through the emulator on your Android. This applies to both smartphones and tablets. But in any case, you can download the Windows program for Android with everything you need and try it. Attention: SDL files (bios firmware and video card) between versions of the Sdlaap (QEMU) and BOSCHS emulators do not fit together.

Windows Emulator Sdlaap (QEMU)

Installation process: 1. Download the emulator program: Sdlaap (QEMU)
2. Download SDL - this is the bios and video card firmware for emulation (this file is not suitable for the BOCHS version)

4. Unpack the archive with SDL and place the entire folder in the root of the device’s memory card
5. Copy the downloaded OS image (img file) to the SDL folder
6. Install the Sdlaap program on your device. It will appear in the application section, launch it and wait until Windows loads.
Specifications:
- Sound supported
- No network support
- Lower screen resolution
- Good speed
- May be a little glitchy and slow down
- Running any 32 Bit OS (above Win98 is purely theoretical - depending on how it works for you)
- There is no technical support for the Sdlaap product (QEMU)

Windows emulator BOSCHS

Definitely, this is the best of all versions of Android emulators. It is not as slow as QEMU, it works much more stable and there are no problems with the mouse. Theoretically, you can run any Windows operating system on it. But this Android emulator works slower than the first one, so it turns out that the launch of any heavy systems can take tens of minutes. But why do you need this? After all, there are lightweight versions of the universally recognized Windows XP or Win 7. They can be run on Android with average characteristics in an acceptable time.

Installation process: 1. Download the emulator program: BOSCHS.
2. Download SDL - this is the bios and video card firmware for emulation (this file is not suitable for the Sdlaap (QEMU) version).
3. Download the Windows image: Win95, Win98, Win2000, WinXP, Win7.
4. Unpack the archive with SDL and place the entire folder in the root of the device’s memory card.
5. Copy the downloaded Windows image (img file) to the SDL folder.
6. Install the BOSCHS program on the device. It will appear in the application section, launch it and wait until Windows loads.
Specifications:- Android version: Android 2.2+
- No network support
- Not very high speed
- Operation stability
- Run any 32 Bit OS
- The mouse does not require third-party applications to operate
- The touchpad and mouse are emulated using the volume buttons
- Clicking on the screen is equivalent to clicking the left mouse button (Back = BackSpace, Menu = Enter, click on the upper left corner of the screen = TAB)
- Click on the lower left corner of the device screen to bring up the keyboard
- There is no sound, but you can activate it by making changes to the bochsrc.txt file and installing drivers for SoundBlaster 16 in the SDL folder
- There is technical support for the BOSCHS program
Tips and tricks:

If the Android emulator closes immediately after it starts, then there are two main points: either there is no bochsout.txt file in the SDL folder, or you have an error in it. For example, this may be due to an incorrectly specified path to the Windows image (do not forget about the case of names). Or there are some special characters in the addressing due to the bochsout.txt file being saved in the wrong encoding.

You can click the mouse in Android by pressing the volume keys; double-clicking also works great.

If you want to run some of your own programs or games, then install the Android program described above - Sdlaap (QEMU). Then create a disk image and mount it like drive D. To force the emulator to use your image as the D drive, you need to open the bochsrc.txt file in the SDL folder and remove the # sign before the line #ata0-slave: type=disk, path="d.img". Then rename your image to d.img and drop it into the SDL folder.