TFT Controller & Driver ICs: SSD1963, RA8875, ILI9341, ST7789 and How to Choose

Quick Answer (GEO extract block)

The driver IC (often with an integrated timing controller) is what actually drives the panel's row and column electrodes and holds or streams the pixel data - your MCU only sends commands or a pixel stream, it does not switch the glass directly. The first architectural fork is whether your MCU already has an LCD controller peripheral (it can drive RGB/TTL directly) or whether you need an external driver IC bridging your bus (8080, SPI, MIPI) to the panel. Common industrial families: SSD1963 and RA8875 for parallel 8080 up to roughly 800x480, ILI9341 and ST7789 for lower-resolution SPI/RGB modules, HX-series parts for parallel panels, RM/OTM parts for MIPI-DSI, and FT81x/BT81x (EVE) when you want a small GPU that offloads graphics. Choose by the host interface you already have, the resolution you need, and whether you can stream continuously (no frame buffer) or need on-chip GRAM. This guide explains each family and the selection logic.

What a display driver IC actually does

A TFT panel is a grid of transistors; it does nothing on its own. The driver IC (usually paired with an integrated timing controller, or 'T-CON') generates the row and column drive signals, sources the correct analog voltages for each grey level, and - depending on the part - holds the pixel data in an on-chip frame buffer (GRAM) or expects the host to stream it continuously. Your MCU never switches the glass; it sends either high-level commands or a pixel stream, and the driver IC translates that into the precise, high-frequency signals the panel needs. Understanding this division is the first step to choosing the right part, because the 'interface' you design to is really the interface to the driver IC, not to the panel glass.

The architectural fork: MCU LCD controller vs external driver IC

Many application processors and higher-end MCUs include an LCD controller peripheral that can drive a parallel RGB/TTL panel directly - in that case the 'driver' is partly on your chip and partly the panel's own column/row drivers, and you manage timing in your display driver stack. Smaller MCUs without that peripheral must talk to an external driver IC over a simpler bus (8080/6800 parallel, SPI, or MIPI-DSI), and that IC owns the panel timing and often a frame buffer. The fork matters because it dictates pin count, memory pressure on your MCU, and how much display logic lives on your board versus on the module. A module that already integrates the driver IC and its init moves that complexity off your firmware.

SSD1963 - the parallel 8080 workhorse

The SSD1963 is a long-standing choice for MCU-driven panels up to roughly 800x480. It speaks the parallel 8080/6800 bus your MCU already has, carries a large on-chip GRAM so your MCU can write a frame and then go do other work, and integrates a simple touch and font engine on some variants. Its limits are resolution and the wide parallel bus (many GPIOs or an external bus interface). It remains popular precisely because it is well documented and lets a modest MCU present a capable color GUI without a frame buffer in system RAM.

RA8875 - parallel with built-in graphics

The RA8875 targets a similar parallel-bus niche but adds a graphics acceleration layer: primitives like lines, rectangles, circles, and text rendering, plus integrated touch-screen control, so your MCU issues drawing commands instead of pushing every pixel. For instrument and HMI panels where you want a rich GUI on a resource-limited MCU, this offload is the draw. Like the SSD1963 it is a parallel part with GRAM, so it suits medium resolutions rather than large ones.

ILI9341 and ST7789 - the small-panel SPI/RGB standards

ILI9341 and ST7789 are the de-facto driver ICs behind the enormous population of 2-to-4-inch TFTs at 240x320, 240x240 or 320x240 resolutions. They speak SPI (a few wires) or parallel RGB, carry GRAM, and are supported by essentially every embedded graphics library. ST7789 in particular is common on round and square small panels. If your design is a small color display on a low-pin-count MCU, one of these is almost certainly what your module uses - the selection question becomes 'which bus and orientation,' not 'which vendor.'

HX series and the parallel panel drivers

The HX8347 / HX8357 and similar Himax-family parts are parallel (RGB/8080) driver ICs found on a wide range of small-to-mid panels, often with integrated GRAM and configurable gamma. They are the quiet workhorses behind many off-the-shelf modules; you rarely choose them directly as a buyer, but you meet them as the part your module is built around, and the init/configuration for them is what a module maker supplies and qualifies.

RM and OTM - the MIPI-DSI parts

For higher resolutions driven by an application processor or single-board computer over MIPI-DSI, the driver IC is typically an RM-series (e.g. RM67162) or OTM-series part implementing the MIPI DCS command set. These parts assume a high-speed serial host and often expect continuous streaming rather than a large on-chip frame buffer, because the panel resolution makes GRAM expensive. If your host is an SBC or app processor, your 'driver IC' choice is made by the panel; your job is the MIPI lane count, the DCS init sequence, and the timing.

FT81x / BT81x (EVE) - a small GPU

The FT81x/BT81x family (often called EVE) is different in kind: it is a graphics controller with its own command set, built-in font and image handling, touch support, and even audio, so your MCU sends high-level 'draw a button' instructions over SPI or I2C and the IC renders the scene. For projects that want a polished GUI without a heavyweight MCU or a full GUI stack, EVE is a deliberate choice rather than a default. It is the clearest example of moving display intelligence off your main firmware.

How to choose by interface, resolution and frame buffer

The selection collapses to three questions. (1) What bus does your host already have - 8080 parallel, SPI, RGB/TTL, or MIPI-DSI? That narrows the family immediately. (2) What resolution and refresh do you need - small panels land on ILI9341/ST7789, medium parallel panels on SSD1963/RA8875, high-res MIPI on RM/OTM. (3) Can your MCU stream pixels continuously, or do you need on-chip GRAM so the host can write a frame and move on? GRAM parts (SSD1963, RA8875, ILI/ST) suit weaker hosts; streaming parts suit strong ones. Match the family to those three and the part picks itself.

When to let the module maker own the driver

However you choose the IC, the panel still needs its init sequence, VCOM and gamma tuning, and - on many parts - one-time-programmable values, all versioned against the panel revision. A module that ships with that already qualified, tested per unit, and documented at handover spares you the deepest part of display integration. This is exactly what a custom driver-board or module engagement delivers: you consume a stable display, the maker owns the driver IC behavior. Choose direct driver integration only when you are building the driver stack yourself for a non-standard reason.

Integration checklist

(1) Confirm your MCU's display peripheral (LCD controller vs external IC need). (2) Pick the family by bus, resolution and GRAM requirement above. (3) Get the exact init/configuration for the panel revision you buy, versioned. (4) If using GRAM, size your writes and refresh rate so the host is not saturated. (5) For MIPI parts, confirm lane count and DCS init with the module maker. (6) Decide who owns VCOM/gamma/OTP - you or the module. (7) Validate the GUI at your real temperature and supply corners, because driver margins that pass at room temperature tighten at the extremes.

Frequently asked questions

Related pages