I want to get into programming on old MS-DOS systems, before then going to older DOSs like CP/M. However, while programming for MS-DOS I'd like to also use era-appropriate software, both for the writing of the code and the compiling of it.

The system I was planning on writing it for is an IBM 5150 Computer, ideally, I'd want to be use assembler as the language of choice.

And I know there were many programs that allowed you to compile assembler, and even more to let you write text. However, I was hoping to get some real recommendations on software from people that were there. So, to anyone who was developing software for the 5150 at the time, what programs were your go-to's at the time?

Please excuse my poor grammar English is not my first language- I'm sorry if this question was too broad, was hoping to get some advice on just starting out :/

  • 11
    I never had a 5150, but Turbo Pascal was a really nice development environment for early IBM compatibles. Definitely my go-to for development at that time. And you can also use Turbo Pascal on CP/M.
    – dirkt
    Commented Oct 20, 2022 at 20:39
  • 1
    I never used the 5150, but I did use a DEC VAXmate (which was an x86, not a VAX; marketing, sigh). I don't recall thinking about it much. Microsoft C and whatever text editor was available. CASE tools were a thing of the future.
    – dave
    Commented Oct 20, 2022 at 21:55
  • 3
    This is kind of chicken and egg problem. Tools and compilers were used on other computers to make the BIOS and OS of IBM 5150, so likely the first programs were also made like on other platforms, before tools and compilers were available on the IBM 5150. See 8086 family reference manual what tools Intel provided on which platforms to make 8086 software.
    – Justme
    Commented Oct 20, 2022 at 22:14
  • 1
    @wizzwizz4 Fine, opened: <retrocomputing.meta.stackexchange.com/q/1151/15334>. Commented Oct 21, 2022 at 5:17
  • 1
    By the way, questions like this are permitted on Quora. You don't always get as good answers as here but there are less restrictions. Polling, opinions, subjective questions, list, all OK there. Commented Oct 23, 2022 at 3:42

13 Answers 13


Turbo Pascal 3.0.

It is hard today to understand how much a revolution it was to go from something that required writing your source file to diskette, exiting the editor and running first the compiler and then the linker to get an executable which you ran from the command line and then back into the editor, to something where everything could fit in the RAM you had.

You could literally run your code in seconds!

The compiler stopped at the first error situation so you still get that retro-feeling. You will want to get the accompanying book as that's the language reference. The download that used to be at https://edn.embarcadero.com/article/20792 did not include the manual.

If you want to fast-forward a bit, Turbo Pascal 5.5 was really nice. Had objects and a debugger. The debugger could even use a second monitor if I recall correctly.

(Turbo Pascal was also available for CP/M - the sensation was even more impressive there)

(Turbo Pascal was an adapted version of the Danish PolyPascal. If you can get hold of that the editor is much, much better!)

  • 2
    Absolutely Turbo Pascal! Version 3.0 came if Wikipedia is correct in 1986, thats when I got my first IBM Copy with dual floppys. Hard-disk came later. I worked 6 years with 68000 development before that. A short while we used a Multics system for text editing, later VAX. Compiling, Assembly, Linking on a connected Motorola 68K dev system and then transfer to our test rigs (intended for real-time control). It could take many hours for a small change to propagate to the test system. What a relief Turbo Pascal was!
    – ghellquist
    Commented Oct 21, 2022 at 11:08

Microsoft’s macro assembler. Because that was the only way of ensuring that all the bugs in the final product were mine.


I used a few things back then:

  1. QuickBasic, starting with version 2.0
  2. Turbo Pascal 3.0
  3. MSC, version 2.0, eventually moving to...
  4. Borland C++, version 3.5

I used (and loved) a text editor called Qedit as my development environment. Somewhat to my surprise it still exists.

I wrote in Microsoft assembler and Microsoft C, though mostly in assembler as in those days C wasn't fast enough to do what I wanted. I used the Microsoft debugger though I remember it with little affection.


The toolset used definitely depended on the kind of software people were developing:

Small, local, and more ad-hoc programs were built using tools like TurboPascal and various Basic compilers. C was not that widely used in such developments as in the early days, suitable C compilers weren't really available, and C was largely considered an exotic "Unix thing". This area is probably the one that will recall most of the personal insights, but it's maybe not 100% representative.

Large-scale, more "professional" development for, say, world market software products (think WordPerfect, VisiCalc, WordStar...) was done using different tools. Note, in the early days of the IBM PC, suitable C compilers were not available, WP, for example, was entirely written using MASM. MASM was thus, in a way, the main development tool for the first years of PC software. Later on, the platforms for large-scale SW development changed onto C compilers (MS, Lattice, Watcom). TurboPascal and Basic were not very prominent (i.e., not at all) in this world. Multiplan was actually one of the first to be developed in (some sort of) C.


Microsoft's BASIC, but I don't remember the version or other details. It was set as requirement for some paid work as a student on university.

The 5150 provided even had a hard disk, 10 MB or so. Wow! I still have its keyboard, for unknown reasons. Recently I built an adapter to connect it via USB to any modern computer.

Good thing that this time did not last for long. :-D


For period-appropriate software, start with the Microsoft assembler and Lattice C, later distributed as Microsoft C 2.0. Other early C compilers I used were Aztec C and Wizard C, which seems to have disappeared from history.

For editing, I used WordStar in non-document mode, although many different editors were available.


Borland Turbo BASIC. I created a very extensive customer management system for a tour operator that ran on an XT clone with 10MB HD & 640KB RAM.

The system issued hundreds of checks & invoices weekly and was in continous use for seven years.

I remember utilizing CHAIN statements to minimize memory use and it worked like a charm - the client was VERY happy...


Depending on the specific project, I initially tended to use Multi-Edit as my program editor, and wrote code in GW-BASIC (either interpreted or using the Microsoft or IBM BASIC Compiler) or Pascal (Microsoft or Turbo compilers). Later, QBASIC/QuickBASIC was added to the list, and occasionally Modula-2 (Fitted Software Tools compiler) or Euphoria (initally from Rapid Deployment Software, later OpenEuphoria).

  • +10 For using Multi-Edit :))
    – Raffzahn
    Commented Oct 21, 2022 at 11:35

gwbasic, Turbo Pascal 3 and 4, dBase III replaced quickly by foxbase and masm.

That's more or less all I've used on my XT PC (PC-Speed emulator on Atari ST). Later on 386 PC at work, Microsoft C 5.1, 6.0 and 7.00 and a little bit of Borland and Watcom C.


In my first professional programming gig in the 80s I was developing on Toshiba laptops (very nice for the time).

I was using the Aztec C compiler and the Vitamin C libraries which provided very basic window-like features. And I mean VERY basic window-like features. Not actual windows.

I typically wrote the code using vi on a mini-computer (a dual Unix universe Pyramid box) and used kermit to transfer the source code to the Toshiba for compiling.

On the laptop itself, I did play around with microEMACS, but as I had used vi throughout my undergrad career I ended up sticking with vi.


As someone active in the PC retroprogramming community -- coding for old systems, directly on those old systems -- as well as having coding experience on the PC since the 80s, I've found that Turbo Pascal 7.0 is the best way to edit/compile/debug both pascal and assembler on such limited hardware. It's good for people who have no experience coding for early IBM PCs: You can start with learning Pascal, then slowly move closer to the hardware with memory and port access, then recode slow inner loops using in-line assembler, and finally can move to 100% assembler, all in the same IDE. The IDE can shell out to the assembler, and if any errors are found you can jump to the line containing the error(s).

For debugging, the Turbo Pascal 7.0 IDE can single-step through in-line assembler as well as included external assembler sources (linked in as .obj modules) with a CPU register and stack display. It can't do this for 100% full assembler programs (ie. non-Pascal programs), but you can use Turbo Debugger if you need that. And both programs can take advantage of dual monitors: With both a color card and a monochrome/MDA card in the system, you can view/edit/debug on one monitor while seeing the output on the other monitor. It's really a hidden gem for assembler development directly on 4.77 MHz 8088-class hardware.

The requirement for the Turbo Pascal 7.0 IDE and tools is a hard disk, and you should have 640KB (or more) for maximum headroom. Adding an expanded memory card can help speed things up (more accurately, help stop things from slowing down even further) but isn't required.

While earlier versions were earlier (Turbo Pascal 3.0, as previously mentioned, came out in 1985), The 7.0 environment mentioned above came out in 1992, over a decade after the IBM PC's release. If your question was really asking "what tools did people use the first few years of the PC's release", and that's what you want to limit yourself to, then the answer would be 1. Any text editor, and 2. Microsoft Macro Assembler (MASM).


Turbo Pascal 2.0 and 3.0 were revolutionary products that made it possible to edit, compile, and run programs entirely within the memory of a PC with 192K of RAM (probably even with 128K). Saving a program to disk before running it was generally a good idea, but the speed of the edit/compile/run cycle was insanely fast. On a floppy-based system, the total time required to load a typical assembler, linker, editor, and source file would exceed the time to build and launch a typical Turbo Pascal program, even if the assembler, linker, and editor could complete their work instantly once launched; of course, since building with such tools would require reading and writing source and object files, the time required to run them would be greater than the time required for Turbo Pascal to process code in memory. Turbo Pascal could also compile from source files stored on disk and/or write generated machine code to an executable file, and was slower when doing so than when doing everything in RAM, but it was still faster than anything else that could do so.

You must log in to answer this question.

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