Hubbry Logo
Multi-Color Graphics ArrayMulti-Color Graphics ArrayMain
Open search
Multi-Color Graphics Array
Community hub
Multi-Color Graphics Array
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Multi-Color Graphics Array
Multi-Color Graphics Array
Multi-Color Graphics Array
View on Wikipedia
from Wikipedia
Multi-Color Graphics Array
Release dateApril 2, 1987; 38 years ago (1987-04-02)
Cards
Entry-levelIBM PS/2 Model 30 & 25 motherboards; Epson Equity Ie motherboard; Delta Computer DG-630 motherboard[1]
History
PredecessorColor Graphics Adapter
SuccessorVideo Graphics Array
Simulated image as displayed using MCGA 640x480 resolution and color abilities.
Simulated image as displayed using MCGA 320x200x256 resolution and color abilities.
Simulated image as displayed using MCGA 320x200x4 graphics resolution and color abilities.
Simulated image as displayed using MCGA 640x200 resolution and color abilities

The Multi-Color Graphics Array or MCGA is a video subsystem built into the motherboard of the IBM PS/2 Model 30, introduced in April 1987,[2] and Model 25, introduced later in August 1987;[3] no standalone MCGA cards were ever made.[4][5][6][7][8][9][10]

The MCGA supports all CGA display modes plus 640 × 480 monochrome at a refresh rate of 60 Hz, and 320 × 200 with 256 colors (out of an 18-bit RGB palette of 262,144) at 70 Hz.[11][3][2] The display adapter uses a DE-15 connector, sometimes referred to as HD-15.

MCGA is similar to VGA in that it had a 256-color mode (the 256-color mode in VGA was sometimes referred to as MCGA) and uses 15-pin analog connectors. The PS/2 chipset's limited abilities prevent EGA compatibility and high-resolution multi-color VGA display modes.

The tenure of MCGA was brief; the PS/2 Model 25 and Model 30 were discontinued by 1990, and the only manufacturer to produce a clone of this display adapter was Epson, in the Equity Ie and PSE-30, since the VGA standard introduced at the same time was considered superior.[12][13]

Software support

[edit]

The 256-color mode proved most popular for gaming. 256-color VGA games ran fine on MCGA as long as they stuck to the basic 320 × 200 256-color mode and didn't attempt to use VGA-specific features such as multiple screen pages.

Games lacking support for 256-color graphics were either forced to fall back to four-color CGA mode, the two-color CGA mode (or never run at all) due to the incompatibility with EGA video modes (320 × 200, 640 × 200, or 640 × 350, all in 16 colors). Some games, including point-and-click adventures from Sierra On-line and Lucasfilm Games, as well as simulation and strategy titles from Microprose, solved this problem for low-resolution titles by supporting the MCGA's 320 × 200 256-color mode and picking the colors most resembling the EGA 16-color RGB palette, while leaving the other available colors in that mode unused.

Higher resolution titles were often unsupported unless graphics could be converted into either MCGA low or high (640 × 480 monochrome, which would also support 640 × 400 and 640 × 350 with some letterboxing) resolution mode in an acceptable fashion. An alternative approach used by a small number of (generally earlier) games was to use four-color CGA assets but make use of the adaptor's ability to freely change the palette for a slightly enhanced appearance.

Output capabilities

[edit]

MCGA offered:[3][2]

  • 640 × 480 monochrome (mode 11h)
  • 320 × 200 in 256 colors (from a palette of 262,144; mode 13h)

CGA compatible modes:

  • 40 × 25 text mode with 8×8 pixel font (effective resolution of 320 × 200; mode 0/1h)
  • 80 × 25 text mode with 8×8 pixel font (effective resolution of 640 × 200; mode 2/3h)
  • 320 × 200 in four colors from a 16 color hardware palette with a pixel aspect ratio of 1:1.2. (mode 4/5h)
  • 640 × 200 in two colors with a pixel aspect ratio of 1:2.4 (mode 6h)

See also

[edit]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Multi-Color Graphics Array

View on Grokipedia
from Grokipedia
The Multi-Color Graphics Array (MCGA) is a video display adapter standard developed by and introduced on April 2, 1987, as an integrated component on the motherboard of entry-level IBM (PS/2) computers, such as the Model 30. It served as an affordable graphics solution to compete with multimedia-oriented home computers, offering improved resolution and over prior IBM standards like the (CGA), while ensuring backward compatibility with CGA display modes. MCGA utilized 64 KB of dual-ported video RAM and an 18-bit (DAC) to support a palette of 262,144 colors (218), enabling up to 256 simultaneous colors in certain modes. Key features of MCGA included support for alphanumeric text modes at 40×25 or 80×25 characters with 16 colors, using a 640×400 resolution in high-density scan mode, and graphics modes such as 320×200 with 256 colors (one byte per ) or 640×480 in with 2 colors (or up to 64 shades of gray). Unlike higher-end PS/2 models equipped with the (VGA), which offered EGA compatibility and more versatile resolutions like 640×480 with 16 colors, MCGA was positioned as a cost-effective option but lacked full EGA emulation without additional adapters. It output analog RGB signals, requiring compatible analog monitors, and was controlled via I/O ports (e.g., 3D4h/3D5h for the cathode ray tube controller) and interrupts like for mode selection and palette programming. MCGA's design emphasized integration and simplicity, with components including a video formatter, gate array, and an 8 KB static RAM character generator for loadable fonts supporting up to 256 characters (with four font tables). It played a role in early PS/2 software ecosystems, such as DOS 4.0's GRAPHICS program for printing text and graphics screens, and OS/2's Presentation Manager for windowed graphical interfaces with multitasking support. Although short-lived and overshadowed by VGA's broader adoption, MCGA represented IBM's push toward enhanced in business computing during the late , influencing subsequent display standards.

History and Development

Origins and Design Goals

In the mid-1980s, faced increasing competition from multimedia-oriented home computers such as the Commodore Amiga and Atari ST, which provided vibrant color graphics capabilities that surpassed the limited palette of the IBM PC's (CGA). To address this gap and appeal to home and entry-level business users, sought to enhance graphics performance in its personal computers without significantly raising costs, motivating the creation of a more accessible video solution. The Multi-Color Graphics Array (MCGA) emerged as part of the Personal System/2 (PS/2) project, which began development in late 1984 and continued into early 1985, with the goal of integrating advanced features into a refreshed PC architecture to regain from clones and rivals. Unlike the (EGA), which relied on dedicated video chips, MCGA was designed for on-board integration to minimize hardware complexity and expenses, enabling low-cost production for budget-oriented PS/2 models. Key design objectives for MCGA included full with CGA modes to ensure software continuity for existing PC users, while introducing new capabilities such as higher-resolution display and low-resolution modes supporting up to 256 colors to broaden multimedia appeal. Conceptualized between 1985 and 1986 as a simplified counterpart to the more advanced (VGA), MCGA targeted entry-level systems like the PS/2 Model 30, prioritizing affordability and ease of integration over high-end performance.

Introduction and Initial Adoption

The Multi-Color Graphics Array (MCGA) was unveiled by on April 2, 1987 as an integrated video subsystem within the newly announced (PS/2) line of computers. It first appeared in the entry-level PS/2 Model 30, which featured an 8 MHz processor and onboard MCGA graphics, eliminating the need for separate expansion cards. The PS/2 Model 25, also powered by an 8086 CPU and similarly equipped with integrated MCGA, debuted later in August 1987 to target educational and home markets. MCGA was limited to these low-end PS/2 models, which used the ISA bus, while the proprietary nature of the PS/2 series—including the (MCA) bus, licensing fees, and compatibility barriers in higher-end models—deterred third-party manufacturers from developing or integrating MCGA-compatible hardware. Early market reception faced challenges from the PS/2's premium pricing, with Models 25 and 30 starting at approximately $2,000, which curbed broader uptake despite strong initial demand—over 1 million PS/2 units sold in the first six months, predominantly the low-end variants. While MCGA advanced color graphics for entry-level systems as a precursor to applications, it was quickly eclipsed by the more capable in upscale PS/2 configurations.

Technical Specifications

Hardware Components

The Multi-Color Graphics Array (MCGA) was integrated directly into the of Models 25 and 30, utilizing a cost-effective design based on custom gate arrays rather than discrete components to reduce expenses. This integration consisted of two gate arrays: the Video Memory Controller Gate Array (part number 72X8300 or 11F8028, manufactured by Seiko-Epson as SLA6430J), which handled clock generation, video addressing, and attribute control; and the Video Formatter Gate Array (part number 72X8205, Seiko-Epson SLA6330J), which managed the CPU interface, mode selection, and display formatting including scan doubling. The video memory subsystem featured 64 KB of (DRAM), implemented using two 64Kx4 chips such as the µPD41264C-15, shared across text and graphics modes to support the array's multifunctional capabilities while minimizing hardware footprint. A dedicated 8 KB static RAM (SRAM) character generator, such as the SRM2264LM-12, stored font data for text rendering. Color processing was managed by a chip, specifically the INMOS IMSG171, which provided a 256-entry color look-up table (CLUT) drawn from an 18-bit palette and included three 6-bit digital-to-analog converters (DACs) for generating analog RGB signals. Unlike predecessors, MCGA omitted a dedicated cathode ray tube controller (CRTC) such as the MC6845; instead, timing signals for 15 kHz and 31.5 kHz analog displays were generated internally by the gate arrays, ensuring compatibility with both and color monitors through auto-sensing. The output interface used a 15-pin connector on the system board rear panel, supporting analog RGB signals for color displays or intensity signal on the channel for monochrome output, with pins configured for , , video, horizontal/vertical sync, and monitor type detection.

Display Modes

The Multi-Color Graphics Array (MCGA) fully retains compatibility with all (CGA) display modes, including text modes at 40 columns by 25 rows and 80 columns by 25 rows, the low-resolution graphics mode of 320×200 pixels with 4 colors from a fixed palette ( mode 4), the high-resolution graphics mode of 640×200 pixels with 2 colors ( mode 6), and the undocumented 320×200 mode with 16 colors ( mode Dh). These CGA-emulated modes are displayed using 400 scan lines by vertically doubling the 200-line graphics content, providing sharper rendering on compatible monitors while maintaining backward compatibility. MCGA introduces two new graphics modes beyond CGA capabilities. The first is a monochrome graphics mode at 640×480 pixels with 2 colors (BIOS mode 11h), operating at a 60 Hz refresh rate and using 480 scan lines for high-detail monochrome output suitable for productivity applications and text-heavy displays. The second is a 256-color graphics mode at 320×200 pixels (BIOS mode 13h), also at 60 Hz, employing a planar memory layout with packed-pixel formatting to support up to 256 colors selected from an 18-bit RGB palette of 262,144 possible colors, ideal for vibrant game visuals. These modes are constrained by MCGA's 64 KB of video . The 640×480 mode requires approximately 38 KB for the frame buffer (1 bit per ), allowing remaining for attribute storage or simple overlays, while the 320×200×256-color mode consumes the full 64 KB (8 bits per ). For CGA-emulated modes, MCGA outputs at a 15 kHz to support legacy TTL or composite monitors, whereas the new modes use a 31.5 kHz analog RGB signal at 60 Hz. Hardware and limitations prevent support for intermediate resolutions such as 640×350 or 640×400.

Color Handling and Output Signals

The Multi-Color Graphics Array (MCGA) employs an 18-bit RGB palette, offering 262,144 total colors through 6 bits per primary channel (, , ), with 256 selectable entries managed via a color look-up table (CLUT). Each palette entry is programmable by software, either through interrupt 10h functions (such as AL=10h for individual registers or AL=12h for blocks) or direct access to I/O ports 3C8h (write address) and 3C9h (6-bit RGB data, requiring three sequential writes per entry). This setup allows dynamic palette adjustments to optimize visual output for specific applications. In the 256-color mode (mode 13h, 320×200 resolution), values stored in video memory directly index the CLUT, enabling the simultaneous display of all 256 palette colors and facilitating techniques like dithering to simulate a wider effective color range or approximate truecolor rendering within the constraints of the mode. For other color modes, such as 4-color (mode 4/5h) or 2-color (mode 6h) at 320×200 or 640×200, the palette provides selectable entries from the full 262,144-color space, though fewer colors are active on-screen. Monochrome modes, including the high-resolution 640×480 (mode 11h), utilize a fixed grayscale mapping without palette programmability, relying instead on a binary selection from the CLUT (typically addresses 00h for black and 07h for white) and supporting blinking attributes inherited from CGA standards for text emphasis. When a monochrome display is detected, the MCGA automatically sums RGB values to produce up to 64 shades of gray, outputting the result as intensity on the green video channel (pin 2 of the 15-pin connector) to ensure compatibility with legacy monochrome monitors. The MCGA generates analog RGB output signals through three 6-bit digital-to-analog converters (DACs), delivered via a 15-pin connector using standard VGA pin assignments: red video (pin 1), green video (pin 2), blue video (pin 3), with corresponding grounds (pins 6, 7, 8), horizontal sync (pin 13), and vertical sync (pin 14). These signals operate at a 31.5 kHz and 60 Hz vertical refresh for new modes, using a 25.175 MHz clock, which supports the 256-color capability but limits bandwidth such that high-resolution modes cannot display more than due to memory addressing and timing constraints (video memory is 64 KB, with color data bus effectively 8 bits for palette indexing in packed-pixel modes). While CGA-compatible modes are supported, the output remains analog rather than TTL digital, and is not generated except as a luminance-derived signal on the green channel for operation.

Compatibility and Comparisons

Backward Compatibility with Prior Standards

The Multi-Color Graphics Array (MCGA), introduced in IBM's PS/2 Model 30, provides full emulation of the (CGA) standard to maintain software compatibility for existing applications. This emulation is achieved primarily through the interrupt 10h (), which handles video mode switching and operations in a manner identical to CGA, allowing programs to invoke CGA modes without modification. For instance, CGA-compatible graphics modes are activated via standard function calls, ensuring seamless transition for legacy software. In graphics modes, MCGA employs pixel doubling techniques to adapt 200-line CGA resolutions for display on 400-line monitors, scaling the image vertically while operating at a 31.5 kHz for all modes, including emulated CGA ones. This adjustment prevents distortion in low-resolution graphics, such as the × 4-color mode, by rendering each as two scan lines tall. CGA modes operate at a 31.5 kHz for compatibility with PS/2 monitors, contrasting with original CGA hardware that used 15 kHz but required different monitors. Text mode support mirrors CGA specifications, offering 80×25 or 40×25 character displays with compatible attributes including blinking, underlining, and foreground/background color combinations derived from the CGA palette. These modes utilize an 8×8 or 8×16 character matrix, with cursor emulation achieved by doubling scan line values to align with higher-resolution displays. However, MCGA does not support monochrome standards like MDA or , limiting compatibility to color-oriented text and graphics. Memory mapping in MCGA aligns closely with CGA conventions, providing 64 KB of video memory addressable from B0000h to BFFFFh for color text and graphics operations, which overlaps with the standard CGA layout at B8000h for text pages. This configuration supports up to four 16 KB video pages, enabling paging and panning as in CGA, with the buffer starting at segment A000h and accessible linearly at B800:0000 for efficient software access in emulated modes. Character definitions are stored in a dedicated 32 KB region, further facilitating CGA-style font loading and display. Despite these preservations, MCGA's emulation has notable limitations, particularly in lacking support for EGA's advanced 16-color 640×350 mode, which requires planar memory organization and higher memory capacities not present in the base MCGA implementation. Emulation is confined to CGA's core 2-color 640×200 and 4-color 320×200 graphics modes, with no provision for EGA's extended palettes or bit-plane addressing, ensuring compatibility but restricting upgrades from EGA-era software. Additionally, the analog RGB output signals in MCGA differ from CGA's digital TTL, necessitating compatible analog monitors for optimal CGA mode rendering, though no support is provided.

Key Differences from VGA

The Multi-Color Graphics Array (MCGA) was designed as a cost-reduced alternative to the (VGA), resulting in several key technical trade-offs that limited its capabilities while maintaining basic compatibility for entry-level systems. Primarily, MCGA featured only 64 KB of video memory, in contrast to VGA's 256 KB, which restricted MCGA to simpler display configurations and prevented support for higher-resolution or higher-color-depth modes that VGA could achieve through its expanded memory banks organized into four 64 KB planes. This memory constraint meant MCGA could not implement VGA's 640×480 resolution with 16 colors (mode 12h), which requires 256 KB and planar addressing, though both support 320×200 with 256 colors (mode 13h) using linear addressing. In terms of display modes, MCGA omitted several advanced options available in VGA, such as the 640×350 resolution with 16 colors (an EGA-like mode) and the 640×480 resolution with 16 colors, limiting MCGA to modes like 640×480 with 2 colors and 320×200 with 256 colors from a palette of 262,144 colors. Both MCGA and VGA support 256 colors at 320×200 by selecting from an 18-bit palette (6 bits per RGB channel) for smooth rendering. These absences positioned MCGA as suitable for basic consumer applications but inadequate for professional or -intensive tasks that VGA supported through its broader mode set, including 400- and 480-scan-line options. Architecturally, MCGA relied on two proprietary IBM gate arrays—a memory-controller gate array integrating CRTC functions similar to the and a video-formatter gate array for data and mode control—resulting in a more integrated but less flexible design compared to VGA's implementation. VGA emulated and expanded upon EGA's discrete chip , incorporating the functions of chips like the 6845 CRTC for timing, the 8524 sequencer for , and attribute controllers for color, all within a single gate array that supported programmable timings, scan rates, and advanced features like panning. This made MCGA's simpler and cheaper but lacking VGA's extensibility, such as support for custom or non-standard resolutions via detailed CRTC register programming. For output signals, both standards used a 31.5 kHz horizontal scan rate with analog RGB connectivity via a 15-pin D-sub connector, but MCGA's integrated 256×18-bit RAMDAC was more basic, focusing on palette-based 256-color output without VGA's enhanced synchronization options for broader monitor compatibility. VGA's RAMDAC, while similarly 18-bit, included improved sync signal handling (e.g., composite and separate HSYNC/VSYNC) and direct color mapping capabilities, allowing better support for multisync monitors and reducing artifacts in high-resolution modes. MCGA's simpler DAC prioritized cost over versatility, limiting it to fixed timings without the programmable overscan or border controls found in VGA. Performance-wise, MCGA's tightly integrated gate array design led to slower mode switching and reconfiguration times, often requiring custom routines and font reloads for transitions between modes, whereas VGA's modular architecture—compatible with add-in expansion cards—enabled faster palette changes via dedicated registers and overall higher throughput for graphics operations. This integration in MCGA reduced manufacturing costs for budget PS/2 models like the Model 30 but made it less adaptable for upgrades or complex software, underscoring VGA's role as the more robust standard for the PS/2 lineup.

Limitations Compared to EGA

The Multi-Color Graphics Array (MCGA) lacked support for key (EGA) display modes, such as the 640×350 resolution with 16 colors (mode 10h) or 320×350 with 16 colors, primarily due to its limited 64 KB of video and absence of planar addressing beyond basic CGA emulation. In contrast, the EGA, introduced in 1984, utilized up to 256 KB of and four-bit planar organization to enable these higher-resolution, multi-color modes suitable for detailed work. This incompatibility restricted MCGA systems from running EGA-optimized software without falling back to lower-resolution CGA modes. While MCGA offered a programmable palette of 256 colors selected from an (262,144 possible colors), it could not replicate the EGA's capability to display 16 colors from a fixed 64-color palette (6-bit RGB) at higher resolutions like ×350. The EGA's intensity bit further enhanced its 16-color set for brighter visuals in professional applications, a feature MCGA approximated through its DAC but without the accompanying resolution support. As a result, MCGA's color advantages were confined to lower 320×200 or ×480 modes, limiting its utility for precision tasks. Hardware-wise, MCGA was integrated directly into the of entry-level models like the Model 30, offering no expansion options via ISA slots, unlike the EGA's flexible add-in card design that allowed memory upgrades and compatibility with diverse systems. Additionally, MCGA omitted EGA features such as support for interactive input, though it provides basic character attributes like underlining and blinking via CGA emulation. These omissions underscored MCGA's consumer-oriented design, prioritizing cost over professional extensibility. Intended for home and entry-level computing, MCGA supported no EGA modes, including 200-line variants, which reduced text crispness on high-resolution monitors compared to EGA's 350-line options favored in CAD and applications since its 1984 standardization. Overall, MCGA represented a short-lived "dead-end" technology, phased out quickly after its introduction in favor of more versatile standards, while EGA persisted in compatible systems until VGA's dominance in the late .

Usage and Legacy

Software and Operating System Support

The BIOS included extensions to the video interrupt services to support MCGA-specific display modes, including mode 11h for 640×480 resolution and mode 13h for 320×200 resolution with 256 colors from a programmable palette. These extensions allowed BIOS-level programming for mode selection via AH=00h, palette and color register management via AH=10h subfunctions (such as 12h for writing individual registers and 16h for block writes), and initialization including default palette loading controlled by AH=12h with BL=31h. Auto-detection of MCGA hardware versus VGA was facilitated through functions like AH=1Bh to return functionality and state information, including display type codes, and AH=03h to read device parameters such as scan lines and monitor type. In the DOS environment, early versions of Microsoft Windows provided limited but functional support for MCGA. The IBM OEM edition of Windows 1.04, released in 1987, included drivers enabling the 256-color mode (mode 13h) for rendering icons and windows, alongside support for VGA, 8514/A, and PS/2 mouse hardware. Windows 2.0 similarly accommodated MCGA through its VGA-compatible drivers, which utilized the 320×200×256 mode with fallbacks to lower resolutions if needed, though full VGA features like 640×480×16 were unavailable on MCGA systems. Programming for MCGA under DOS typically involved direct I/O port access to the range 3C0h–3CFh for attribute controller operations, mode setting via the miscellaneous output register at 3C2h, and DAC palette loading at 3C8h–3C9h, without reliance on later standards like VESA extensions that were incompatible with MCGA's limited capabilities. Operating systems like 1.0, released in 1987 concurrently with the PS/2 line, offered full native support for MCGA on hardware, including integrated video services for PS/2 models via calls and device drivers tailored to the platform's architecture. In contrast, (1990) classified MCGA as "VGA-compatible" in its display setup, enabling basic 256-color operations but excluding higher-resolution color modes beyond MCGA's hardware limits, with drivers defaulting to monochrome or low-color fallbacks for compatibility. Third-party driver development for MCGA was sparse, largely due to the proprietary (MCA) bus in PS/2 systems, which imposed licensing requirements, complex configuration via adapter descriptor files (.ADF), and higher design costs (10–50% more than ISA/AT equivalents), deterring widespread adoption by non-IBM vendors. IBM addressed this through reference implementation details in its Personal System/2 Hardware Interface Technical Reference and BIOS Interface Technical Reference manuals, providing developers with port mappings, interrupt handlers, and sample code for MCGA integration.

Applications in Games and Early Computing

The Multi-Color Graphics Array (MCGA) found limited but notable applications in early , particularly those leveraging its 320×200 resolution with 256-color palette for enhanced visual detail over prior standards like CGA. For instance, the 1989 , developed by and published by , supported MCGA alongside other adapters, allowing it to display its rotoscoped animations in full 256 colors at 320×200, which improved the vibrancy of environments and character movements compared to its original CGA composite mode adaptations. This mode was detected via calls, enabling the game to fallback to CGA if MCGA was unavailable, a common practice in software of the era due to MCGA's rarity outside systems. In productivity applications, MCGA's 640×480 mode was intended for text-based and software, offering higher resolution for editing and data visualization without color support. However, compatibility issues arose, such as display artifacts in graphics modes for software like version 2.01, which required workarounds like disabling MCGA to avoid garbage output in setups. For home and educational computing, MCGA-equipped systems were often bundled with kid-oriented software packages that capitalized on the 256-color mode for engaging visuals. The Kidware Kit, distributed by Mobius Corporation, included educational titles optimized for PS/2 hardware, using the colorful low-resolution mode to illustrate interactive lessons in subjects like math and language. A later example, (1992) from Interplay Productions, provided MCGA compatibility in its DOS version, rendering Nintendo-licensed animations and typing interfaces in 256 colors to appeal to young users on legacy hardware. MCGA's brief prominence waned by 1990 as VGA and SVGA standards proliferated, but its 256-color 320×200 mode left a legacy in influencing early "VGA" game development through shared mode 13h palette handling. MCGA also supported early DOS utilities like the GRAPHICS.COM program in DOS 4.0 for capturing and text and screens from MCGA modes. Due to MCGA's confinement to low-end PS/2 models, few games were exclusively designed for it; most relied on detection for graceful degradation to CGA, ensuring broader accessibility. Today, MCGA applications are preserved through emulators like , which simulate its modes for running historical software.

References

  1. http://ps-2.kev009.com/pcpartnerinfo/ctstips/7492.htm
  2. https://ardent-tool.com/docs/scans/BYTE_1987_06_IBM_PS2.pdf
  3. http://mutantstargoat.com/~nuclear/tmp/prog_guide_pc_ps2_video_sys.pdf
  4. https://bitsavers.trailing-edge.com/pdf/ibm/pc/ps2/Held_-_IBM_PS2_Users_Reference_Manual_1989.pdf
  5. https://www.ardent-tool.com/video/MCGA.html
  6. https://hackaday.com/2022/06/02/have-you-heard-of-mcga/
  7. https://www.pcworld.com/article/465931/the_ibm_ps_2_25_years_of_pc_history.html
  8. https://www.userlandia.com/home/ibm-ps2-model-30-286
  9. https://www.ibm.com/history/ps-2
  10. https://www.computinghistory.org.uk/det/6110/ibm-introduces-the-ps-2-series-of-computers/
  11. https://www.ardent-tool.com/qtechinfo/8525.html
  12. https://www.theregister.com/2017/04/04/30_years_ago_ibms_final_battle_with_reality/
  13. https://librarytechnology.org/document/4431
  14. https://www.ardent-tool.com/docs/pdf/PS2_Model_25_Technical_Reference_Jun87.pdf
  15. https://www.swiat-owocow.pl/lang/en/1285.html
  16. https://www.ardent-tool.com/video/PS2_Video_Programming.html
  17. https://scalibq.wordpress.com/2022/09/29/vga-and-mcga-whats-the-difference/
  18. https://dfarq.homeip.net/mcga-vs-vga/
  19. https://www.dosdays.co.uk/topics/graphics.php
  20. https://minuszerodegrees.net/oa/OA%20-%20IBM%20Enhanced%20Graphics%20Adapter.pdf
  21. https://bitsavers.org/pdf/ibm/pc/ps2/15F0306_PS2_and_PC_BIOS_Interface_Technical_Reference_May88.pdf
  22. https://archive.org/details/IBMWindows104720k
  23. https://www.os2museum.com/wp/os2-history/os2-1-0/
  24. https://www.ardent-tool.com/tech/MCA_vs_AT_Bus.html
  25. http://www.dosdays.co.uk/topics/Games/game_prince.php
  26. https://www.mobygames.com/game/196/prince-of-persia/specs/
  27. https://www.atarimagazines.com/compute/issue113/p92_KIDS_TIME.php
  28. https://www.pcgamingwiki.com/wiki/Mario_Teaches_Typing
  29. https://scalibq.wordpress.com/2018/01/06/more-pcjr-incompatibilities/
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.