No, a 1.77 inch 128x160 display is not good for a mini PC as a primary monitor, but it can serve specific niche purposes if you know what you're doing. The core issue is physical size and resolution density. A 1.77 inch diagonal screen with 128x160 pixels gives you a pixel density of roughly 116 PPI (pixels per inch). For comparison, a typical 24-inch 1080p monitor has about 92 PPI, and a modern smartphone (like a 6.1-inch 1080p display) hits around 430 PPI. So the 1.77 inch display is not particularly sharp by today's standards, but it's not the resolution that kills it for a mini PC—it's the usable screen real estate. You cannot run a full desktop OS like Windows 11 or Ubuntu with a graphical interface at 128x160. Even a basic file manager or a terminal window with 80 columns of text will not fit. The display only supports about 20–25 characters per line at a readable font size, which is impractical for any real work.
However, I've seen people use these tiny displays as secondary status panels for a mini PC. For example, you can hook it up via SPI or I2C (using a driver like the ST7735S, which this specific 1.77 inch 128x160 tft display uses) to show system metrics like CPU load, RAM usage, network traffic, temperature, or even a simple clock. The SPI interface runs at 4-wire or 3-wire, typically up to 20 MHz, which is fast enough to update a small display at 30–60 FPS for simple graphics. The ST7735S controller supports 65K colors (16-bit RGB565), so you can render basic charts or text with decent color depth. But don't expect to watch videos or browse the web on it. The viewing angle is decent for a TN-based TFT (typically 60–80 degrees horizontal and vertical), but the brightness is usually around 200–300 nits, which is fine for indoor use but washes out in direct sunlight. The refresh rate is capped at about 60 Hz, but for static data display, that's irrelevant.
Let's break down the technical specs and compare them to what a mini PC actually needs. A mini PC usually runs a full x86 or ARM OS, with a desktop environment that expects at least 1024x768 resolution for basic usability. The 128x160 display is only 0.02% of that pixel count. If you try to use it as a primary display, you'll need to scale down the resolution in the OS, but most graphics drivers (like Intel UHD or AMD Radeon) don't support such low resolutions natively. You'd have to use a custom framebuffer or a virtual display driver, which is a pain. The display's physical size is also a problem: 1.77 inches diagonal means the active area is about 35.5 mm x 28.4 mm (1.4 x 1.12 inches). That's smaller than a credit card. You can't read text comfortably unless you glue a magnifying lens to it.
Where this display shines is in embedded or headless mini PC setups. For example, if you're running a Raspberry Pi Zero or a small x86 SBC (like a LattePanda or a Rockchip-based board) as a server, you can use this display to show a simple boot status, IP address, or error codes. The SPI interface uses only 4–5 GPIO pins (SCLK, MOSI, DC, CS, and optionally RESET), which is efficient for a low-pin-count microcontroller or a single-board computer. The power consumption is also low: typical draw is around 30–50 mA at 3.3V, which is about 0.1–0.17 watts. That's negligible compared to a mini PC's 10–30 watt idle power. So if you're building a low-power server or a dedicated monitoring device, this display is a good fit.
But let's be real about the build quality and durability. The 1.77 inch TFT panels are usually glass-based with a thin polarizer, so they're fragile. The connector is a 14-pin or 20-pin FPC (flexible printed circuit) with a 0.5 mm pitch, which is easy to damage if you're not careful. The module I linked uses a 4-wire SPI interface, but some versions also support 8-bit parallel, which is faster but uses more pins. The ST7735S driver IC has a built-in frame buffer of 128x160x16 bits = 40,960 bytes, which is tiny. That means you don't need external RAM, but you're limited to the same resolution. The color depth is 16-bit, which gives 65,536 colors, but the gamma correction is fixed, so color accuracy is not great. For a status display, that's fine.
Now, let's talk about the software side. To use this display with a mini PC, you'll need to write a driver or use an existing library. For Linux, there's a kernel driver for the ST7735 (fb_st7735r) that works with the framebuffer subsystem. You can set it up as a second framebuffer (e.g., /dev/fb1) and then use a tool like fbi or a custom Python script to render text. For Windows, you'll need a custom driver or use a microcontroller (like an Arduino or ESP32) that communicates with the mini PC via USB and then drives the display. That adds complexity. The SPI bus on a mini PC is usually not exposed directly; you'd need to use a USB-to-SPI adapter (like an FT232H) or a GPIO header if your board has one. Most mini PCs (like Intel NUCs or ASUS PN series) don't have accessible GPIO pins, so you'd have to solder or use a breakout board. That's a hassle.
Let's compare this display to alternatives. A 5-inch 800x480 HDMI display costs about $20–30 and is plug-and-play with any mini PC. It gives you 10x the resolution and 5x the diagonal size. A 3.5-inch 480x320 TFT with SPI costs about $10 and is still larger. The 1.77 inch display is only worth it if you have extreme space constraints, like a custom enclosure that's the size of a matchbox, or if you're building a wearable mini PC (which is a stretch). The table below shows the key specs:
| Parameter | 1.77 inch 128x160 | Typical Mini PC Monitor |
|---|---|---|
| Diagonal size | 1.77 inches | 21.5 inches |
| Resolution | 128x160 | 1920x1080 |
| Pixel density | 116 PPI | 102 PPI |
| Color depth | 65K (16-bit) | 16.7M (24-bit) |
| Interface | SPI (4-wire) | HDMI/DisplayPort |
| Power consumption | ~0.1W | ~20W |
| Refresh rate | 60 Hz | 60 Hz |
| Viewing angle | 60° H/V (typical) | 178° H/V (IPS) |
| Cost | ~$5–8 | ~$100–200 |
As you can see, the 1.77 inch display is not a replacement for a monitor. But if you're building a dedicated system that only needs to show a few characters, like a server status panel, it works. For example, you can use it with a Raspberry Pi Zero 2W running a headless OS, and write a Python script that uses the Adafruit ST7735 library to display CPU temperature and load. The SPI bus on the Pi Zero runs at 32 MHz, so you can update the display at 50 FPS with simple graphics. The response time of the LCD is about 10–15 ms, which is fine for static data. The backlight is LED-based, usually with a lifespan of 20,000 hours, but that's typical for cheap TFTs.
One more thing: the pixel layout of 128x160 is not standard for most software. Most GUI frameworks (like Qt, GTK, or even SDL) expect a 4:3 or 16:9 aspect ratio. This display is 128:160 = 4:5, which is portrait mode. So if you mount it in a landscape orientation, you'll have to rotate the framebuffer, which adds overhead. The ST7735S driver supports hardware rotation via register commands, but it's not always reliable. You'll likely need to use software rotation, which costs CPU cycles. On a low-power mini PC like an Intel Atom, that might be noticeable.
In terms of reliability, these displays are mass-produced in China and have a typical failure rate of 1–2% for DOA (dead on arrival). The FPC connector is the weakest point—if you bend it too much, the traces break. The glass is also prone to cracking if you apply pressure. The operating temperature range is usually 0–50°C, which is fine for indoor use but not for an industrial environment. The ST7735S driver IC has a built-in voltage regulator for the LCD bias, so it only needs 3.3V input, but the backlight requires a separate 3.3V or 5V supply (depending on the module). The module I linked uses a 4-wire SPI, which is the most common, but some versions have a 3-wire SPI (without DC pin) which is slower but saves one pin.
If you're determined to use this display with a mini PC, here's a practical setup: Get a mini PC with a USB port and a GPIO header (like a Raspberry Pi 4 or a Libre Computer board). Connect the display to the SPI pins. Install a lightweight OS like DietPi or Alpine Linux. Write a script that reads system stats from /proc and /sys and renders them on the display using the framebuffer. Use a monospaced font at 8x8 pixels, which gives you 16x20 characters (16 columns, 20 rows). That's enough to show 8 lines of text with 16 characters each, which is fine for a few metrics. The update rate can be 1 Hz to avoid flicker. The whole thing draws less than 1W total, so you can run it 24/7.
But let's be honest: for most people, a 1.77 inch display is a novelty, not a practical tool. The only reason to use it is if you're building a tiny, low-power, headless system that needs a minimal visual output. For example, a network switch monitor, a weather station display, or a portable retro gaming console (but that's not a mini PC). The 128x160 resolution is too low for any modern GUI, and the size is too small for comfortable reading. If you're building a mini PC for actual work, get a proper monitor. If you're building a hobby project, this display is fun to play with, but don't expect it to replace a real screen.