What was the first program that was created as a dedicated IDE? That is, purpose built for coding, rather than simply allowing integration as part of its expansion options.

This is opposed to a text editor that has generic plugin/add-in/shell features that are were not dedicated to development work.

The features I am thinking about that would qualify an editor as an IDE:

  • Code highlighting
  • Integrated compiler invocation (with error reporting)
  • Code navigation features
  • (optionally) integrated debugger

Sub question - what was the first Visual IDE? (by which I mean with an integrated GUI designer).

  • 5
    Removed "+1" after I saw that you could have looked up that easily on Wikipedia. en.wikipedia.org/wiki/Integrated_development_environment
    – Doc Brown
    May 24, 2012 at 11:30
  • 11
    Nitpick: Wikipedia's claim that "Dartmouth BASIC was the first language to be created with an IDE" is unsourced. If someone can find good references for that, they won't be just providing the correct answer here but they could also fix the Wikipedia article.
    – yannis
    May 24, 2012 at 11:35
  • 1
    As I said you can assign it, if in full gui one can easily write a little plugin/vimscript that assigns it to the menus. Several such plugins exist which is how modern IDE's often handle various compilers...
    – ewanm89
    May 24, 2012 at 12:22
  • 1
    When you say "Integrated compiler invocation" do you mean the IDE ships with its own integrated compiler, possibly produced by the same vendor as the IDE? I suppose that would exclude most editors (like Vim), but that could also be argued as an artificial constraint if Vim (and others) make the integration with external compiler appear to be seamless. May 24, 2012 at 14:45
  • 1
    @FrustratedWithFormsDesigner - I wanted to exclude editors that were not primarily created for coding (so VIM, VI and EMACS for instance, would be excluded). I meant purpose built.
    – Oded
    May 24, 2012 at 16:09

5 Answers 5


I'd nominate dBase II which appeared in 1979. It had integrated compilation and code editing/navigation and debugging. No code highlighting though - but I don't regard that as a prerequisite for making something an IDE, personally.

  • How common were displays that could show multiple colours back then? I guess syntax highlighting would be dependent on that. Except for highlighting that changes fonts and styles instead - was that ever commonly used on monochrome systems instead? May 24, 2012 at 16:12
  • Color on PCs was rare until the PC-AT (1984). Black on white was common for highlighting menus etc. copied from mainframe terminals. In early PCs the fonts were actually in hardware on the graphics card May 24, 2012 at 16:21
  • dBase 2 and other similar things of the time worked on serial terminals, where you could use colour (eg VT100 derivatives) as well as various forms of highlighting. The big thing in the late 70's / early 80's was to get away from black and white, to either green and black (the famous IBM green screen being the precursor there) and for a while Amber and black was very big. Apr 22, 2013 at 5:54
  • Those old screens could vary the intensity of text (or invert it, or make it flash, though you wouldn't want to code much with either of those!) but you might typically save that sort of thing for mode lines/status bars/etc. because those were not part of the file being edited. Apr 22, 2013 at 10:21

In the mainframe world (which of course pre-dates the Apple and IBM PC world by decades), there were several on-line editors that were capable of editing source code in several languages - such as COBOL, Assembler and PL/1 as well as "job control language" (JCL).

Some of these editors had features for allowing the display of compiler output on a 3270 visual display. For the OS/VS1 and MVS Operating systems there was ICCF (that ran under CICS) and ISPF.

For full screen interactive debugging there was OLIVER (for CICS applications) and SIMON (for Batch) for DOS/VSE, OS/VS1 and MVS, MVS/XA operating systems. Both OLIVER and SIMON had an ISPF-like interface (for both Operating Systems, including DOS/VSE which didn't have its own native ISPF).Both OLIVER and SIMON allowed in flight changes to data fields and statement "bypassing" on-the-fly, which permitted a limited form of program change.OLIVER also provided automatic memory protection ensuring task isolation and it intercepted all program checks before they even occurred.

It was possible to switch easily between ICCF/ISPF source editing and debugging modes - simply by pressing a Program function key - so it provided a seamless interface that would be recognized as an IDE today. This was from the early 1970's.

If there had been graphic displays freely available in the early 1970's these products would surely have used them to their fullest extent - so it was hardware that was the limiting factor at that time. As it was, colour and foreground/background highlighting were the only ways of identifying important items on screen.

A further point - A comprehensive on-line interactive Spreadsheet application known as The Works Records System was created as early as 1974 using the OLIVER debugging tool. This was at ICI UK - six years before Visicalc for the Apple II.


IBM's Interactive System Productivity Facility (ISPF).

Copying from wikipedia:

ISPF primarily provides an IBM 3270 terminal interface with a set of panels. Each panel may include menus and dialogs to run tools on the underlying Time Sharing Option (TSO). Generally, these panels just provide a convenient interface to do tasks—most of them execute modules of IBM mainframe utility programs to do the actual work. ISPF is frequently used to manipulate z/OS data sets via its Program Development Facility named ISPF/PDF, where PDF refers to Program Development Facility.

SPF was developed and sold in the late 1970's. ISPF was sold in the early 1980's. I think the minicomputer emulators of ISPF mentioned in Wikipedia, like SPFPC, were sold in the late 1980's. The first time I actually used ISPF was 1982. Before that, I worked with minicomputers in the oil and gas industry.

  • Year? 1980? Wikipedia unclear on this
    – Warren P
    Jun 14, 2012 at 0:01
  • @Warren P: SPF was developed and sold in the late 1970's. ISPF was sold in the early 1980's. I think the minicomputer emulators of ISPF mentioned in Wikipedia, like SPFPC, were sold in the late 1980's. The first time I actually used ISPF was 1982. Before that, I worked with minicomputers in the oil and gas industry. Jun 14, 2012 at 12:06
  • would you mind explaining more on what it does and what it's good for? "Link-only answers" are not quite welcome at Stack Exchange
    – gnat
    Apr 20, 2013 at 7:44
  • SPF / ISPF allowed code editing + integration with the compilers, generally FORTRAN and perhaps PL/1, though the integration was very limited. For example, tracking back through interactively generated compiler errors was not very easy. Running a batch compilation and using split-screen mode did allow browsing the compilation listing in 1/2 the screen and doing editing in the other 1/2. This was common through the late 1970's and into the early 1980's (at least). Apr 22, 2013 at 5:57

According to Wikipedia, the first language that was specifically created together with an IDE for that language was Dartmouth BASIC in 1964. However, that probably depends on your definition of "IDE". The way LISP development is done, and LISP is typically implemented, there is really no distinction between the language and the IDE, so I wouldn't be surprised to find examples earlier than that.

  • 2
    See my comment to the question.
    – yannis
    May 24, 2012 at 11:35

After reading @DocBrown 's remark that the Wikipedia page on IDE's has a History section with the answer, and @YannisRizos 's objection that the first IDE listed there is not a sourced statement, I scrolled down one further paragraph in that Wikipedia page and read:

Maestro I is a product from Softlab Munich and was the world's first integrated development environment[1] 1975 for software.

where [1] is a bibliography source (in German): "Interaktives Programmieren als Systems-Schlager". The article is from Computerwoche, a magazine directed at IT managers and CIOs, originally published September 21, 1975. They describe the Maestro I system as a 'Programm-Entwicklungs-Terminal-System', which translates as 'program development terminal system'.

A 'similar system' is mentioned: 'Stico' from a company called 'ZEDA', which was around a year and half before August 1976, which makes it around February 1975. However, STICO is described in the second linked article as a 'system that creates out of few instructions a complete program and converts it immediately into an executable object program', which looks more like an alternative language, or a set of macros, or a compiler, than an IDE.

In trying to understand which features of Maestro I would classify it as an IDE, it seems the main innovation at the time was the interactive development it allowed:

Maestro fed each keystroke directly to the CPU producing immediate feedback. This feedback was also enabled by the particular characteristics of the hardware, specifically the use of a keyboard and console instead of the earlier punchcards or tape. -- http://en.wikipedia.org/wiki/Maestro_I

which makes me wonder what is the difference to a LISP REPL, then. But hey, I just wanted to overcome the 'cite your sources' problem mentioned above.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.