8086 Emulator Download Kits
Keena Wiegert
I was looking for 8086 kits that I could put together and I've only found three so far. I'd like to know if anyone else knows of any more. The ones that I found so far are this S-100 board, this one that uses a GAL22V10 decoder and a few more that aren't sold anymore* or don't come with schematics. I guess most people are probably making 8088 kits because of the PC and simpler wiring but I'd really to find a good 8086 one to compare my own work against and I thought someone here might know better than the search engines.
We made an Intel 8086 Emulator in Rust. The commandline version is at : -Emulator. Then we compiled it to WASM and integrated with React to make a front-end only 8086 Emulator website. Repository is -Emulator-Web/. It is hosted on GitHub pages at : -emulator-web/.
Please check it out, and let us know how it is. If you think it is interesting, please start the repos ?
In my recent semester we had Microprocessors as a subject, and more than half of it was based on Intel 8086 microprocessor. Now usually when the labs for this were taken, one would probably use some kind of kits or such to write programs of 8086 instruction set x86 assembly, and test it out. But... as this time it was conducted online, we had to use something else. Now the emulator we were supposed to use , in my opinion , had some issues.
While searching for some other 8086 emulator to use, I came across -simulator/, which is a 8085 emulator. This seemed a really cool thing, made in Angular and using JS to run the assembly. (Check it out as well, it is quite cool!)
But other than that, I couldn't find a 8086 emulator.
As I had seen the 8085 emulator, it seemed a pretty good idea to make mine also in web version, but I didn't want to write complete Lexer and parser part in JS. As I also wanted to make a commandline version as well, the best Option seemed to be making a core library in Rust and then make different interfaces for both version, compile Web version to WASM and integrate it with front-end. And (bad Rust pun ahead..) that turned to be Some(Emulator) ?
So, my friends and me went ahead, and made the core library, the 'drivers' (interfaces for both versions) and the React frontend, compiled Rust code to WASM, tries to integrate them, found bugs in code, fixed bugs in code ; Rinse and repeat few more times, and got ourselves an 8086 emulator ? ?
Both versions allow most of the instruction set of 8086 assembly, with exceptions of few instructions used to interface with external devices or so, and only allows selected few interrupts, as it does not store the instructions in memory which is required by Interrupt Service Routines. It gives complete 1 MB Memory to store data, and access to all registers which 8086 architecture has.
The SDK-86 MCS-86 system design kit is a complete single board 8086 microcomputer system in kit form. It contains all necessary components to complete construction of the kit, including LED display, keyboard, resistors, caps, crystal, and miscellaneous hardware. Included are preprogrammed ROMs containing a system monitor for general software utilities and system diagnostics. The complete kit includes an 8-digit LED display and a mnemonic 24-key keyboard for direct insertion, examination, and execution of a user's program. In addition, it can be directly interfaced with a teletype terminal, CRT terminal, or the serial port of an Intellec system. The SDK-86 is a high performance prototype system with designedin flexibility for simple interface to the user's application.
The SDK-86 (system design kit) was the first available computer using the Intel 8086 microprocessor. It was sold as a single board kit at a cheaper price than a single 8086 chip because Intel thought that the success of a microprocessor depends on its evaluation by as many users as possible. All major components were socketed and the kit could be assembled by anyone having a limited technical knowledge thanks to a clear and complete assembly manual. The system could be used with the on-board keyboard and display or connected to a serial video terminal.
The HSE-49 emulator of 1979 was a stand-alone development tool with on-board 33-key keypad, 8-character display, two 8039 microcontrollers, 2K bytes of user-program RAM, a serial port and cable, and a ROM-based monitor which supervises the emulator operation and user interface. The emulator provides a means for executing and debugging programs for the 8048/8049 family of microcontrollers at speeds up to 11 MHz. It interfaced to a user-designed system through an emulation cable and 40-pin plug, which replaced the MCS-48 device in the user's system. Using the HSE-49 keypad, a designer can run programs in real-time or single-step modes, set up to 8000 breakpoint flags, and display or change the contents of user program memory, internal and external data memory, and internal MCS-48 hardware registers. When linked to a host Intellec development system, the HSE-49 emulator system-debugging capabilities, with the development system program assembly and storage facilities, provide the tools required for total product development.
EMU8086 - MICROPROCESSOR EMULATOR is a free emulator for multiple platforms. It provides its user with the ability to emulate old 8086 processors, which were used in Macintosh and Windows computers from the 1980s and early 1990s. It can emulate a large amount of software that was used on these microprocessors, but a savvy user can also program their own assembly code to run on it.
EMU8086 - MICROPROCESSOR EMULATOR primarily emulates the processor, not the other functions that a microcomputer running a 8086 processor would have. However, it still serves many of the same functions that an emulator for a more specific microcomputer might have, and more besides. For example, both the NEC-P9801 and early IBM-compatible computers used the 8086. Using EMU8086, one might be able to write assembly software that can run on either of those devices. On the flip side, EMU8086 can't access some of the more advanced hardware functionality that you might find in the monitors or other components of those devices.
Overall, EMU8086 - MICROPROCESSOR EMULATOR will be useful to computing enthusiasts and gearheads, and anyone who happens to work with this legacy processor even today: some computers, particularly in business and industrial applications, still use the 8086. Whether it's to tinker or to work, if you think you might want to emulate the 8086, start here.
Hi, all. I've been writing an 8086 (actually 80186) PC emulator for the Arduino Due. You can interface with it via VNC using a Wiznet 5x00 Ethernet module/shield. I'm working on making it function on a Mega2560 as well, but that's not working quite right yet. Will update if I get that going.
There is a CPU emulation engine which steps through the memory the same way a real 8086 does, interpreting and executing x86 machine instructions how the original CPU does, but with equivalent C code and variables simulating the hardware logic and registers.
It uses an SD card in raw mode as a hard disk. You can either just start with my included disk image, or make your own and install DOS with another emulator like PCem/86Box/Fake86. The emulator expects 16 heads, 63 sector disk geometry. It can be up to a 500 MB image.
So, the speed. It's pretty slow. Quite a few times slower than a real 8086/8088. With a VNC client connected, it's much worse while video memory is being written to! Sending out all the screen updates in real time slows it way down. It's really bad. Don't expect to be be playing any games at usable speeds. I'm not sure how much this can be mitigated, but if anybody wants to have a go at optimization, have at it! Share your improvements if you want.
I'm looking for a tiny libc (C runtime library) targeting small model DOS 8086, and providing (most of) the C89 library functions, including fread(...), printf(...) and scanf(...). The libc must work with at least one of these C compilers: Watcom C, Borland C++, Microsoft C or Zortech C++. The libc must seperate unrelated functions, so e.g. if printf(...) and scanf(...) are not used in the source code, then they shouldn't be linked into the final program. Also it should be possible to specify that I don't need floating point support in printf(...) and scanf(...), so they will become smaller.
It looks like such a tiny libc doesn't exist, and the existing full libcs (implementing most C89 functions) for DOS 8086 have too much bloat. Compared to those, the bloat of the dosmc libc is tiny, but that libc is way too incomplete: it doesn't have printf(...) or scanf(...) (and most other C89 functions).
It would be possible to create such a libc (complete C89, tiny bloat) by starting with the dosmc libc, and adding functions from newlib one-by-one, carefully checking and ensuring that unused functions mustn't contribute any initialization code, and malloc(...) isn't a dependency of the initilization code. Given enough time, some of the newlib functions (e.g. printf(...)) could be rewritten in hand-optimized 8086 assembly, or replaced with simiplified, shorter implementation (available to be chosen by the application programmer at compile time, e.g. printf(...) without floating point support, malloc(...) without free(...)).
SubC libc from 2018. Most of it is implemented in C, the DOS system-specific parts (crt0-dos-8086.s) are in 8086 assembly. It's not optimized for size, but it's simple and relatively complete. The assembly parts have to be split to separate source files to reduce the unused bloat. It can be used as inspiration and as a baseline when implementing size-optimized libcs.
PDOS PDPCLIB 4.00 from 2019. A full C89 libc with speed optimizations. Most of it is implemented in C, the DOS system-specific parts (dosstart.asm and dossupa.asm) are in 8086 assembly (in syntax common to TASM, WASM nd MASM). It can be compiled with Turbo C++ (and Borland C++), and OpenWatcom 2. The assembly parts have to be split to separate source files to reduce the unused bloat. It can be used as inspiration and as a baseline when implementing size-optimized libcs.
aa06259810