# FAQ (/faq) ## Is there a cloud? Do I need an account? [#is-there-a-cloud-do-i-need-an-account] No cloud, no account, no subscription. The backend is a web app **you** host (Docker or Home Assistant add-on), and frames run entirely on-device once deployed. You can shut the backend down and your frames keep rendering, keep their schedules, and stay controllable over their [local HTTP API](/guide/control). ## Can I run this on an ESP32? [#why-no-microcontrollers] Yes. FrameOS runs on the **ESP32-S3**: the backend builds a firmware image, you [flash it from the browser](/guide/esp32), and the device renders scenes on-device with the same scene interpreter as Linux frames, plus QuickJS for code nodes. It syncs scene changes over WiFi and updates its firmware over the air with automatic rollback. It can even deep-sleep between refreshes, which makes battery-powered frames viable. That said, the **Raspberry Pi is still the recommended platform**. A full Linux system gives FrameOS room a microcontroller can't match: * **Displays** - the Pi drives [110+ panels](/devices) including 1600×1200 six-color Spectra 6; the ESP32 firmware targets Waveshare SPI e-paper panels and headless builds. * **Real rendering at any size** - dithering a 13.3" color panel takes more RAM than most microcontrollers have in total. The S3's 8MB PSRAM handles 800×480 in black/white. * **Apps that need an OS** - headless Chromium screenshots, Python-based drivers, on-disk assets. Use a Raspberry Pi for scenes that depend on those features. A Pi Zero 2 W idles around one watt, so Pi frames are wall-powered. If you want a wire-free frame that refreshes a few times a day, the [ESP32 build](/guide/esp32) is now the better tool - and it's the same backend, the same scenes, and no cloud either way. ## Can the backend and the frame run on the same Raspberry Pi? [#can-the-backend-and-the-frame-run-on-the-same-raspberry-pi] Yes, on a Pi 4/5 with some patience. Install the backend via the [release tarballs or Docker](/guide/backend) on the Pi, then add the frame with `localhost` as its address. For e-ink frames a more common setup is: run the backend on your laptop only when you want to change something - the frame doesn't need it day to day. ## What happens when my WiFi or internet goes down? [#what-happens-when-my-wifi-or-internet-goes-down] The frame keeps rendering whatever its scenes can produce locally. Apps that fetch remote data serve their cached values. The control page on port 8787 keeps working as long as you can reach the frame on the network. When connectivity returns, everything catches up on the next render. ## How fast can it render? [#how-fast-can-it-render] On a Raspberry Pi 5 over HDMI: up to **60 frames per second**. On e-ink, the panel itself is the bottleneck - color e-ink takes \~15-30 seconds per refresh, monochrome panels a second or two. FrameOS only refreshes the physical display when the rendered image actually changed, so e-ink panels don't flash needlessly. ## Can I show my own photos? [#can-i-show-my-own-photos] Yes. Upload images to the frame's **Assets** and use the *Local image* app, point the *Image from URL* app at any address, sync a folder over SSH, or use gallery apps (FrameOS Gallery, Unsplash, Wikimedia Commons, OpenAI image generation). ## Does it integrate with Home Assistant? [#does-it-integrate-with-home-assistant] Three ways: the backend runs as a [Home Assistant add-on](/guide/backend#home-assistant-add-on); the **HA Sensor** app pulls any Home Assistant entity into a scene; and HA automations can drive frames through the [HTTP API](/guide/control) - change text, switch scenes, trigger renders. ## How do I share scenes or apps I made? [#how-do-i-share-scenes-or-apps-i-made] Scenes export as JSON (and as ZIP templates with preview images) you can share anywhere. The community hangs out on [Discord](https://discord.gg/9dT9y7EzUw) - show off your builds, get help, and propose contributions. Code lives at [github.com/FrameOS/frameos](https://github.com/FrameOS/frameos); PRs welcome. ## What does it cost? [#what-does-it-cost] FrameOS is free and open source (AGPL-3.0). A complete frame is roughly the price of the panel plus \~$20 of Pi: a 7.5" black/white build lands around $80, a 13.3" Spectra 6 color build around $250. ## Is there a hosted/cloud option coming? [#is-there-a-hostedcloud-option-coming] The core promise stays: frames run locally, forever, with no account. A hosted backend (for those who don't want to self-host one) is being explored - follow the [blog](/blog) and [newsletter](https://buttondown.com/frameos) for news. # 3D-printed cases (/cases) A frame isn't finished until it stops looking like electronics. The **FrameOS Case Maker** at [cases.frameos.net](https://cases.frameos.net) generates a parametric, 3D-printable case around your exact panel and Raspberry Pi - in the browser, powered by OpenSCAD. [The FrameOS Case Maker](https://cases.frameos.net) Pick your panel model and Pi, then customise: * case depth and bezel dimensions * print-in-place **kickstands** * wall-mounting holes * USB power cutouts * screw posts and heat-set insert holes * SD card access, side buttons, Pi cooling …then download the STL and print it. Printed cases with kickstands The case designs are open source at [github.com/FrameOS/cases](https://github.com/FrameOS/cases) - PRs with new panel dimensions are very welcome. For a full build walkthrough (13.3" and 7.3" Spectra panels, slim builds, USB-C ports, heat-set inserts), watch the [e-ink build video](/blog/eink-spectra-waveshare-pimoroni). # FrameOS Remote (/guide/agent) The on-device companion formerly called the **agent** is now called [**FrameOS Remote**](/guide/remote). This page is kept so old links still resolve. Use the [FrameOS Remote guide](/guide/remote) for the current docs. # Editing apps (/guide/apps) Every blue and green node on a scene is an **app**: a small program with typed config fields, an optional image output, and access to the scene's state. FrameOS ships with \~40 built-in apps (clocks, calendars, weather, Home Assistant sensors, OpenAI text & images, QR codes, RTSP camera snapshots, web page screenshots, image manipulation, layout splitting…), and you can edit or write your own. ## Edit any app [#edit-any-app] Click the **edit** button next to any app on a scene to open its source. You can edit all apps, including the built-in ones - saved changes are forked onto that scene, leaving the original untouched. Editing an app Apps run with full access on the frame. Read the source before installing scenes or apps from strangers. ## Nim apps [#nim-apps] Built-in apps are written in [Nim](https://nim-lang.org/) and compiled into the frame's binary - this is how a $15 Pi Zero 2 W stays fast. A minimal render app: ```python title="color.nim" import pixie import options import frameos/apps import frameos/types type AppConfig* = object inputImage*: Option[Image] color*: Color App* = ref object of AppRoot appConfig*: AppConfig proc render*(self: App, context: ExecutionContext, image: Image) = image.fill(self.appConfig.color) # called when used as a render app (blue node) proc run*(self: App, context: ExecutionContext) = render(self, context, context.image) # called when used as a data app (green node) proc get*(self: App, context: ExecutionContext): Image = result = if self.appConfig.inputImage.isSome: self.appConfig.inputImage.get() elif context.hasImage: newImage(context.image.width, context.image.height) else: newImage(self.frameConfig.renderWidth(), self.frameConfig.renderHeight()) render(self, context, result) ``` Things to know: * The `render` event is your starting point - it fires on the scene's timer, or when dispatched by another app. * The `context` carries the `image` you draw on (via [pixie](https://github.com/treeform/pixie)) and the scene's `state`, a standard Nim [JsonNode](https://nim-lang.org/docs/json.html): read with `state{"field"}.getStr()`, write with `state{"field"} = %*("value")`. * State is cleared on every render; use instance variables on the `App` object to persist data between renders. * Learn by example: the [built-in apps](https://github.com/FrameOS/frameos/tree/main/frameos/src/apps), [types.nim](https://github.com/FrameOS/frameos/blob/main/frameos/src/frameos/types.nim), and the [utils/](https://github.com/FrameOS/frameos/tree/main/frameos/src/frameos/utils) folder show what's available. ## JavaScript apps [#javascript-apps] You can also write apps in **JavaScript/TypeScript**. They run on the frame inside an embedded [QuickJS](https://bellard.org/quickjs/) runtime - no Node.js needed on the device. Create one from the code templates (text, logic, SVG, or image), define its fields in `config.json`, and export plain functions: ```ts title="app.ts" export function init(app: FrameOSApp): void { app.initialized = true } export function get(app: FrameOSApp, context: FrameOSContext): string { return `${app.config.prefix}: ${app.config.message}` } ``` JS apps can fetch data with `frameos.fetchText()` / `frameos.fetchJson()`, return text, JSON, SVG markup, or images, and plug into scenes exactly like Nim apps. They're the fastest way to write custom logic without touching a compiler. # The backend (/guide/backend) The backend is the control panel for your frames. You use it to design scenes, deploy them over SSH, and manage them through [FrameOS Remote](/guide/remote) when they connect back to the backend. It's a single self-hosted web app - there is no hosted cloud version and no account to sign up for anywhere. The FrameOS backend A few things worth knowing up front: * The backend needs **network access to your frames** for first deploys and direct status checks (SSH and HTTP). After [FrameOS Remote](/guide/remote) is installed, frames can also connect back to the backend over an outbound WebSocket. * The backend **does not need to stay running**. Frames work fully standalone after a deploy. Keeping it running gets you log aggregation, metrics, and one-click redeploys. ## Quick install [#quick-install] The backend is the control panel that **deploys to** your frames - it is not the software that runs on the frame itself. Run the command below on the machine that will manage your frames: your laptop, a server, or a NAS. The frame's Raspberry Pi is set up separately in the [next step](/guide/raspberry), and never listens on port 8989. The easiest way to install on a Mac or a Debian/Ubuntu Linux machine: ```bash bash <(curl -fsSL https://frameos.net/install.sh) ``` The script installs Docker if needed, then runs the `frameos/frameos` container on port `8989`. Once it's up, open `http://localhost:8989` on that same machine (or `http://:8989` from another device) and create your local account. ## Home Assistant add-on [#home-assistant-add-on] If you run Home Assistant, FrameOS is one click away: 1. Go to **Settings → Add-ons → Add-on Store** in Home Assistant. 2. Click the **⋮** menu in the top right corner and select **Repositories**. 3. Add `https://github.com/FrameOS/frameos-home-assistant-addon`. 4. Find **FrameOS** in the add-on list, click **Install**, then **Start**. 5. Optionally enable **Start on boot** and **Watchdog**. 6. Click **Open Web UI**. ## Running via Docker manually [#running-via-docker-manually] This is what the install script does under the hood: ```bash # generate a stable secret key SECRET_KEY=$(openssl rand -base64 32) mkdir -p db # run the latest release docker run -d --name frameos --restart always \ -p 8989:8989 \ -v ./db:/app/db \ -e SECRET_KEY="$SECRET_KEY" \ frameos/frameos:latest ``` Then open `http://localhost:8989` and create your local account. To keep the container automatically up to date, add [watchtower](https://containrrr.dev/watchtower/): ```bash docker run -d --name watchtower \ -v /var/run/docker.sock:/var/run/docker.sock \ containrrr/watchtower --interval 86400 frameos ``` ### Faster builds with Docker access [#faster-builds-with-docker-access] SD card image generation works in the default container without extra privileges. If you also want the backend to **cross-compile FrameOS from source** in local build containers (instead of using precompiled binaries or building on the device), give it access to Docker: ```bash SECRET_KEY=$(openssl rand -base64 32) mkdir -p db /tmp/frameos-cross docker run -d --name frameos --restart always \ -p 8989:8989 \ -v ./db:/app/db \ -v /tmp/frameos-cross:/tmp/frameos-cross \ -v /var/run/docker.sock:/var/run/docker.sock \ --privileged \ -e TMPDIR=/tmp/frameos-cross \ -e SECRET_KEY="$SECRET_KEY" \ frameos/frameos:latest ``` This is optional: for common targets FrameOS ships **precompiled binaries**, and you can also configure remote SSH build servers, or build on the frame itself, under **Settings → Builds**. ## Local development with Flox [#local-development-with-flox] Use this path when you want to work on FrameOS itself instead of running the released Docker image. The repository ships a checked-in [Flox](https://flox.dev/) environment that installs the Python, Node, pnpm, Nim and Redis tooling used by the backend and frontend. ```bash git clone https://github.com/FrameOS/frameos.git cd frameos flox activate pnpm dev ``` `flox activate` creates a repo-local `.venv`, installs `backend/requirements.txt`, runs `pnpm install --frozen-lockfile`, and installs the Nim dependencies for both the frame runtime and FrameOS Remote. The activation hook reruns only when the lockfiles or package definitions change. `pnpm dev` opens an `mprocs` dashboard with the local services: * **backend** - FastAPI on `http://localhost:8989` with `DEBUG=1`. * **worker** - the ARQ background worker used for deploys and builds. * **vite** - the live frontend on `http://localhost:8616`, proxying `/api` and `/ws` to the backend. * **kea** - frontend type generation in watch mode. * **redis** - local Redis for jobs, logs, websockets and Remote connections. Open `http://localhost:8616` once the backend and Vite panes are ready. In development mode the backend runs database migrations before startup and creates a local `.env` with a development `SECRET_KEY` if you do not already have one. If you prefer to run processes manually, start Redis with either the `redis` pane in `pnpm dev` or Flox services: ```bash flox services start redis pnpm run dev:backend pnpm run dev:worker pnpm --dir frontend run dev ``` ## Next step [#next-step] Time to prepare your Raspberry Pi: [set up the Raspberry](/guide/raspberry). # Controlling the frame (/guide/control) Every frame runs its own web server on port `8787`. This is the heart of FrameOS's cloud-free design: viewing, controlling, and even administering a frame works **directly against the device**, from any browser or script on your network. The backend can be off. The internet can be down. ## The frame's web app [#the-frames-web-app] Open `http://:8787/` for the frame's own web UI: * **`/`** - view the current image, live (updates over a WebSocket). * **`/c`** - the control page: switch scenes and edit the active scene's state fields (the yellow nodes you added in the [scene editor](/guide/scenes)). * **`/admin`** - the on-device admin panel: settings, logs, metrics, assets, scene management. This is a full management UI served by the frame itself. By default the frame also renders its control URL as a **QR code on the display**, so anyone standing in front of the frame can scan and control it. Control via QR code ## Access modes [#access-modes] Under the frame's settings you choose who can do what without a key: * **Private** (default) - a key is required to view and to control. * **Protected** - anyone on the network can view the image; the key is required to change anything. * **Public** - no key needed for anything. Makes for the smallest QR codes. The access key travels as a `?k=...` query parameter (or a cookie after the first visit). Traffic is plain HTTP on your local network. If you need real security - frames on a shared network, remote access - put the frames on a [Tailscale](https://tailscale.com/) tailnet or enable the HTTPS options in the frame's settings. ## The HTTP API [#the-http-api] Everything the control page does is a plain HTTP call. With `KEY` being your access key: ```bash # the current image as PNG curl "http://frame:8787/image?k=KEY" -o now.png # the active scene and its state curl "http://frame:8787/state?k=KEY" # all scenes and their states curl "http://frame:8787/states?k=KEY" # change state fields on the active scene and re-render curl -X POST "http://frame:8787/event/setSceneState?k=KEY" \ -H "Content-Type: application/json" \ -d '{"render": true, "state": {"message": "Dinner at 7!"}}' # switch to another scene curl -X POST "http://frame:8787/event/setCurrentScene?k=KEY" \ -H "Content-Type: application/json" \ -d '{"sceneId": ""}' # trigger a render right now curl -X POST "http://frame:8787/event/render?k=KEY" -d '{}' ``` `POST /event/` dispatches any event into the running scene graph - the same mechanism buttons, schedules, and apps use internally. This makes integrations trivial: a Home Assistant automation, a cron job, a shell script, or a doorbell webhook can all drive your frame. There's also a full admin REST API (config, logs, metrics, restart, reboot) under `http://frame:8787/api/` behind the admin login, and a WebSocket at `/ws` that streams renders. ## Scheduling [#scheduling] Frames have their own on-device scheduler: render intervals per scene, plus cron-like schedules (minute/hour/weekday) that can switch scenes or fire events - for example, a calendar during the day and art in the evening. Configure it under the frame's **Schedule** tab. The schedule runs on the frame, so it keeps working with the backend off. # The ESP32 (/guide/esp32) FrameOS also runs on **ESP32-S3 microcontrollers** - no Linux, no SD card, no SSH. The backend builds a firmware image for your frame, you flash it over USB (straight from the browser), and from then on the device renders scenes on its own and updates itself over the air. ESP32 builds target Waveshare SPI e-paper panels plus a headless mode. Each firmware image contains one selected panel driver. The Raspberry Pi remains the broadest platform for HDMI/LCD, Pimoroni panels, Python-backed drivers, and OS-dependent apps - see [which to pick](#raspberry-pi-or-esp32) below. ## What you need [#what-you-need] * **An ESP32-S3 board with PSRAM.** The reference board is the [Seeed XIAO ESP32-S3](https://www.seeedstudio.com/XIAO-ESP32S3-p-5627.html) (8MB flash, 8MB octal PSRAM) - rendering happens in PSRAM, so don't skip it. * **A supported panel**: a Waveshare SPI e-paper panel, wired over SPI - or no display at all. IT8951 and 12.48" Waveshare panels still need a Raspberry Pi. * **The [backend](/guide/backend)**, with the ESP-IDF toolchain available (see below). ## Backend toolchain [#backend-toolchain] Firmware images are built by the backend, which needs [ESP-IDF](https://docs.espressif.com/projects/esp-idf/) v5.5.x on its host: If you run the FrameOS backend with Docker, you are already set: the Docker image includes ESP-IDF and Nim, so browser flashing and firmware builds work without installing the toolchain on your host machine. For non-Docker backend installs, install ESP-IDF manually: ```bash mkdir -p ~/esp && cd ~/esp git clone --depth 1 --branch v5.5.4 --recursive --shallow-submodules \ https://github.com/espressif/esp-idf.git cd esp-idf && ./install.sh esp32s3 ``` The backend finds it via the `IDF_PATH` environment variable, falling back to `~/esp/esp-idf`. For non-Docker installs, the firmware build also needs **Nim 2.2+** on the backend's PATH. ## Flash the device [#flash-the-device] 1. Click **New frame** in the backend and choose **Flash embedded device**. 2. Pick the **ESP32-S3** platform, your display panel, and enter your WiFi credentials. 3. The backend builds the firmware image, baking in the WiFi details, backend address, frame API key and panel config. 4. Connect the board over USB and click **Flash from browser**. This uses Web Serial, so it works in Chrome and Edge. Alternatively, download the image and flash it by hand: ```bash esptool.py --chip esp32s3 --port /dev/tty.usbmodem* --baud 460800 write_flash 0x0 frameos-esp32-s3.bin ``` The device boots fully provisioned: it joins your WiFi, registers with the backend, and starts rendering. ### Provisioning by hand [#provisioning-by-hand] Flashing a generic image instead? Two more ways to configure the device: * **Captive portal**: an unprovisioned device starts a WiFi hotspot called `FrameOS-XXXX`. Join it and any web page redirects to the setup form (WiFi, backend URL, frame ID/API key, panel, and GPIO pins). * **Serial console** (115200 baud) - always available, and quickest for tinkering: ``` frameos> status frameos> wifi MySSID MyPassword # saves and reboots frameos> set panel EPD_7in5_V2 frameos> render # render immediately frameos> ota # check for an OTA update now frameos> factory-reset ``` ## Scenes on a microcontroller [#scenes-on-a-microcontroller] Install scenes exactly like on any other frame. The device syncs them from the backend as JSON and renders them **on-device**: the same scene interpreter that runs on Linux frames runs on the ESP32, with code nodes and expressions on QuickJS and the standard apps compiled into the firmware. Scene updates arrive over WiFi - no reflashing. On the S3, an 800×480 scene renders in about 400 ms, plus \~530 ms for dithering down to the panel's 1-bit palette. The default refresh interval is 5 minutes; scenes can request their own. Apps that need a real OS - headless Chromium screenshots, Python-based drivers, local asset storage - are not available on the microcontroller. Use a Raspberry Pi for scenes that depend on those OS-backed features. ## Updates and control [#updates-and-control] * **Over-the-air updates**: the firmware uses A/B partitions with automatic rollback - if a new build fails to come up, the next reset boots the previous one. The device checks the backend for new firmware daily, or on demand. * **HTTP**: the device serves `GET /status` (heap, PSRAM, WiFi and render stats as JSON), plus `POST /api/action/render` and `POST /api/action/ota` on port 80. * **Battery mode**: `set deep_sleep 1` on the console makes the device deep-sleep between refreshes - this is where a microcontroller frame beats a Pi on power. ## Wiring [#wiring] Default pins target the XIAO ESP32-S3: | Signal | GPIO | XIAO label | | ------ | ---- | ---------- | | CS | 3 | D2 | | DC | 4 | D3 | | RST | 5 | D4 | | BUSY | 6 | D5 | | SCK | 7 | D8 | | MOSI | 9 | D10 | Remap at runtime with `set pins rst=5,dc=4,cs=3,busy=6,sck=7,mosi=9,pwr=-1` on the serial console, in the captive portal, or per-frame in the backend. ## Raspberry Pi or ESP32? [#raspberry-pi-or-esp32] | | Raspberry Pi | ESP32-S3 | | ------------------ | -------------------------------------------- | ----------------------------------------------------------------------- | | Displays | [110+ drivers](/devices): e-ink, HDMI, LCD | Waveshare SPI e-paper (one panel driver per firmware image) or headless | | Scenes | Everything | Interpreted scenes, standard apps | | Apps needing an OS | Chromium screenshots, Python drivers, assets | Not available | | Power | \~1 W, wall-powered | Deep sleep between refreshes - battery is viable | | Updates | SSH deploys | OTA with A/B rollback | | Price | \~$15-20 (Zero 2 W) | \~$8-10 (XIAO ESP32-S3) | In short: pick the Pi unless you specifically want a battery-powered frame or have a soft spot for microcontrollers. More panels and capabilities are on the [roadmap](https://github.com/FrameOS/frameos/blob/main/TODO.md); want to help port a panel? See the [firmware README](https://github.com/FrameOS/frameos/tree/main/embedded/esp32) and say hi on [Discord](https://discord.gg/9dT9y7EzUw). ## Next step [#next-step] [Deploy your first scene](/guide/first-deploy). # First deploy (/guide/first-deploy) This assumes you have the [backend running](/guide/backend) and a [Raspberry Pi reachable over SSH](/guide/raspberry) (or booted from a FrameOS SD image). Using an [ESP32](/guide/esp32) instead? Flash it first - the scenes and deploy flow below work the same way. ## Add the frame [#add-the-frame] Click "New frame" in the backend. Give the frame a name and select the right **display driver** for your panel - there are over 120 to choose from, organised by vendor. For Raspberry Pi frames, enter the frame's IP address or hostname and SSH credentials for the first deploy. Pick "Web only" if you just want to try FrameOS without any display hardware. Adding a frame ## Install some scenes [#install-some-scenes] Install a few scenes onto the frame. Good first picks: * **Gallery scenes** like *Made in Space* or *Masterpieces* - curated art that needs no configuration. * **Sample scenes** like *Calendar*, *Message board*, or *Unsplash image* - some need API keys, which you can add under the backend's **Settings** page. Adding scenes ## Deploy [#deploy] Press **Deploy**. The backend shows a deploy plan - what gets uploaded, what gets installed - and streams the progress log. The first deploy takes the longest (it installs dependencies and uploads the FrameOS binary); subsequent deploys are fast and only ship what changed. When it finishes, a preview image appears in the backend, followed by the same image on the frame itself. Deploy finishing The image on the physical frame ## Control the frame [#control-the-frame] Scenes expose controls - a calendar URL, a message to display, a color. Change them from the frame's dashboard in the backend, or directly on the frame itself: * Open the **Control URL** (shown under the frame's settings) from any browser on your network. * Or scan the **QR code** shown on the frame. Scene control fields The frame serves this control page itself, on port `8787`. The backend doesn't need to be running - see [Controlling the frame](/guide/control) for the full local HTTP API. ## Next step [#next-step] Build your own scene in the [scene editor](/guide/scenes). # What is FrameOS? (/guide) FrameOS turns a Raspberry Pi (or an [ESP32](/guide/esp32)) and a display into a **single-function smart frame**: a kitchen calendar, a hallway dashboard, a daily art frame, a meeting room display, a thermostat - anything that should show one thing, reliably, for years. It works with screens that update **60 times per second** (HDMI, LCD) and with screens that update **once every 60 seconds or slower** (e-ink). Over a hundred display drivers are built in, covering most Waveshare and Pimoroni e-ink panels, plus anything you can plug into HDMI. Frames around the house ## How it works [#how-it-works] FrameOS has two parts: 1. **The frame** runs a single compiled binary (written in [Nim](https://nim-lang.org/)) on a Raspberry Pi - or as firmware on an [ESP32-S3](/guide/esp32). It renders scenes, drives the display, and serves a small web app + HTTP API so you can view and control it from your phone or any browser. Everything runs **on the device** - there is no cloud, no subscription, and nothing stops working when your internet goes down. 2. **The backend** is a self-hosted control panel (a Docker container, or a Home Assistant add-on) where you design scenes in a visual editor and deploy them to frames over SSH or [FrameOS Remote](/guide/remote). It can run on a server, a NAS, or just your laptop - and once your frames are deployed, **you can turn it off**. The frames keep running on their own. FrameOS primarily targets the Raspberry Pi (from the $15 Zero 2 W up) - a full Linux system gives you SSH deploys, real fonts and image processing, a local web server, and room to run real apps. It also runs on the **ESP32-S3** microcontroller, rendering scenes on-device and updating over the air for supported Waveshare SPI e-paper panels. [See the ESP32 guide](/guide/esp32). ## What you need [#what-you-need] * **A Raspberry Pi.** A [Zero 2 W](https://www.raspberrypi.com/products/raspberry-pi-zero-2-w/) is perfect for e-ink frames. Use a Pi 4/5 for fast HDMI output (up to 60 FPS). Or go smaller with an [ESP32-S3](/guide/esp32) for supported panels. * **A display.** Any [supported e-ink panel](/devices) from Waveshare or Pimoroni, an HDMI screen, or no display at all ("web only" and "http push" modes). ESP32 builds currently target Waveshare SPI e-paper panels or headless mode. * **Somewhere to run the backend**, at least while deploying: your computer, a server, or Home Assistant. ## Getting started [#getting-started] 1. [Install the backend](/guide/backend) on **your computer or server** (not on the frame's Raspberry Pi) - one command: ```bash bash <(curl -fsSL https://frameos.net/install.sh) ``` 2. [Set up the Raspberry Pi](/guide/raspberry) - flash a prebuilt FrameOS SD image, or use stock Raspberry Pi OS Lite. (Or [flash an ESP32](/guide/esp32) instead.) 3. [Deploy your first scene](/guide/first-deploy) - pick from the built-in gallery and sample scenes, then make your own in the [scene editor](/guide/scenes). 4. For a professional finish, [3D print a custom case](/cases). ## Project status [#project-status] FrameOS is open source ([AGPL-3.0](https://github.com/FrameOS/frameos/blob/main/LICENSE)) and under very active development, with versioned releases on [GitHub](https://github.com/FrameOS/frameos/releases) and Docker Hub (`frameos/frameos`). It's stable enough that frames run for months unattended - but expect the occasional rough edge, and [report it](https://github.com/FrameOS/frameos/issues) when you find one. * Join the [FrameOS Discord](https://discord.gg/9dT9y7EzUw) * Subscribe to [the newsletter](https://buttondown.com/frameos) * Star us on [GitHub](https://github.com/FrameOS/frameos) # The Raspberry Pi (/guide/raspberry) Check the [device-specific instructions](/devices) for your display - a few panels need extra steps. ## Which Pi to choose? [#which-pi-to-choose] * **Raspberry Pi Zero 2 W** - the sweet spot for e-ink frames. Four 64-bit cores, tiny, \~1 W of power, around $15-20. This is what most FrameOS frames run on. * **Raspberry Pi 5 / 4** - use these for fast HDMI/LCD output (up to 60 FPS) or when size doesn't matter. * **Raspberry Pi Zero W (v1)** - works, but it has a single 32-bit core. Cheaper, slightly lower power draw, much slower to deploy to. Not a Pi person, or dreaming of a battery-powered frame? FrameOS also runs on the [ESP32-S3 microcontroller](/guide/esp32) for supported Waveshare SPI e-paper panels. ## Option 1: prebuilt FrameOS SD image (recommended) [#option-1-prebuilt-frameos-sd-image-recommended] For the Raspberry Pi Zero 2 W, FrameOS ships a purpose-built SD card image - a minimal Buildroot-based Linux that boots straight into FrameOS. No Raspberry Pi OS, no manual SSH setup. You can get it two ways: * **Generate it in the backend**: when you add a new frame, choose the SD card image option. The image comes out preconfigured with your WiFi credentials and frame settings - flash it, insert, done. * **Download a generic image** from the [latest release](https://github.com/FrameOS/frameos/releases) (look for `frameos-*-raspberry-pi-zero-2-w-buildroot.img.gz`). On first boot the frame starts a WiFi hotspot called `FrameOS-Setup` (password `frame1234`). Join it from your phone, enter your WiFi credentials, and the frame connects to your network. Flash the image with [Raspberry Pi Imager](https://www.raspberrypi.com/software/) ("Use custom image"), [balenaEtcher](https://etcher.balena.io/), or plain `dd`. The partitions expand to fill your SD card on first boot. ## Option 2: stock Raspberry Pi OS Lite [#option-2-stock-raspberry-pi-os-lite] For all other Pi models, or if you prefer a standard OS underneath: 1. Download the [Raspberry Pi Imager](https://www.raspberrypi.com/software/) and pick the **Lite** version of Raspberry Pi OS (no desktop needed). * 64-bit for Pi 3, 4, 5, Zero 2 W. * 32-bit for Pi 1, 2 and the original Zero W. Raspberry Pi Imager OS selection 2. When prompted, **edit the OS customisation settings**: set a hostname, your WiFi credentials, and enable SSH. Use a password, or better, generate an SSH keypair and paste the public key. SSH key settings in the imager 3. Write the card, insert it into the Pi, connect the display, and power up. 4. Wait for the Pi to appear on your network, then verify you can reach it: ```bash ping frame.local # or check your router's client list for the IP ssh pi@frame.local ``` 5. Once connected, bring the OS up to date: ```bash sudo apt update -y && sudo apt upgrade -y ``` That's all. Given SSH access, the FrameOS backend does the rest - including installing dependencies and (for most targets) deploying **precompiled binaries**, so there's no slow on-device compilation. ## Next step [#next-step] [Deploy your first scene](/guide/first-deploy). # FrameOS Remote (/guide/remote) Frames can optionally run **FrameOS Remote**, a small companion process that opens an outbound WebSocket connection to your backend. Older FrameOS releases and some old docs called this the "agent"; the current name is Remote. Remote means: * The backend can manage frames **without inbound SSH access** once Remote is installed - useful for frames behind NAT, on another network, or with SSH locked down. * Logs and metrics stream to the backend in real time. * The backend's **Terminal** panel can open a browser shell on the frame. * Deploy, restart and maintenance actions can go through the existing Remote connection. Remote is installed and updated automatically when you deploy to a Raspberry Pi frame. On FrameOS SD card images it's part of the system from first boot. It authenticates with a per-frame shared secret, so a Remote connection only controls the frame it belongs to. Like everything else in FrameOS, Remote is optional. A frame renders fine without Remote, without SSH, and without the backend running. Remote exists to make managing frames easier, especially when they are no longer on the same network as your laptop. # Editing scenes (/guide/scenes) A **scene** is what a frame shows: a graph of connected nodes that runs on the device. Scenes are built in a visual editor in the backend, then compiled and deployed onto the frame. ## Create a scene [#create-a-scene] Click **+ Add new scene**, give it a name, and open the editor. Creating a new scene ## The four node colors [#the-four-node-colors] * 🟥 **Red - events.** Entry points that trigger execution. The most important one is `render`, which fires at a set interval (every 60 seconds, every hour, whatever you choose). Others react to button presses, schedules, or custom events. * 🟦 **Blue - render apps.** Draw things: images, text, calendars, gradients, split layouts. * 🟩 **Green - data apps.** Fetch and transform data: download an image, query Home Assistant, parse an iCal feed, generate an image with OpenAI, take a screenshot of a web page. * 🟨 **Yellow - state fields.** User-editable values (text, numbers, options) that can be changed live from the control page without redeploying. Drag from the `render` event's connector to add a blue **Render image** app: Adding a render app Then drag its **image** field out and pick a green data app to feed it - use **FrameOS Gallery** if unsure. Press deploy: Adding a data app ## Caching [#caching] Every data app has cache controls. A scene might re-render every minute while its data app only fetches a new image every 15 minutes - the cached value is reused in between. And if a re-render produces the same image as before, an e-ink display won't refresh at all: no unnecessary flashing. Cache controls ## State fields [#state-fields] Add a yellow **state field** under the scene's "State" tab, then drag it onto the canvas and wire it into any app input. Deploy once, and from then on you can change the value live - from the frame's control page, the backend, or the [HTTP API](/guide/control). Adding a state field Editing state live ## Code nodes [#code-nodes] For quick data plumbing there are inline **code nodes** (green when not selected): single expressions in Nim that combine or transform values mid-graph - string concatenation, math, formatting. Code nodes ## How to learn [#how-to-learn] FrameOS ships with many sample scenes. The fastest way to learn is to install them, open them in the editor, and poke around. Sample scenes in the editor When the visual editor isn't enough, write your own apps - in Nim or JavaScript. [Editing apps](/guide/apps) is next. # Useful settings (/guide/settings) A tour of the most useful options under a frame's **Settings** tab. ## Frame access [#frame-access] Each frame's HTTP server (port `8787`) has three access modes - **private**, **protected**, and **public** - controlling who needs the access key to view or control the frame. See [Controlling the frame](/guide/control) for details. ## QR control code [#qr-control-code] By default the frame overlays its control URL as a QR code on the display. You can position it, restyle it, or turn it off entirely. ## Assets [#assets] Downloaded images (OpenAI, Unsplash, galleries…) are saved to `/srv/assets` on the frame's SD card when there's enough free space. This avoids re-downloading (and re-paying for) the same images after a reboot. Browse them under the frame's **Assets** tab, and reuse them with the **Local image** app. ## Nightly reboot [#nightly-reboot] Frames reboot nightly by default - cheap insurance against memory leaks on a device meant to run for years. To anyone watching, it looks like a regular re-render. You can disable it or change the time. ## Time zone [#time-zone] Set the frame's time zone so schedules, clocks, and calendars line up. Time sync works out of the box on both Raspberry Pi OS and the FrameOS SD images. ## Debug logging [#debug-logging] Enable debug logging to get per-app timing in the logs - useful to find out which app slows down your renders. ## Builds [#builds] Under the backend's settings you can choose how FrameOS binaries get built for your frames: precompiled release binaries (the default for supported targets), local Docker cross-compilation, a remote SSH build server, or building on the device itself. # Framebuffer & HDMI (/devices/framebuffer-hdmi) The **HDMI / Framebuffer** driver renders straight to the Raspberry Pi's video output. Anything you can plug into the HDMI port works: TVs, computer monitors, small HDMI LCD panels, projectors. This is also the fast path: on a Raspberry Pi 5, FrameOS can push **60 frames per second** to an HDMI display, while the same scene system also runs e-ink panels at one frame per minute. ## Setup [#setup] 1. Connect the display to the Pi's HDMI port. 2. Select the **HDMI / Framebuffer** driver when adding the frame. 3. Set the width and height to match the display's resolution, then deploy. ## Power control [#power-control] You can turn the display output on and off from the command line - handy in schedules: ```bash vcgencmd display_power 0 # off vcgencmd display_power 1 # on ``` # HTTP upload (bring your own display) (/devices/http-upload) **HTTP upload** pushes every rendered image to a URL of your choosing as an HTTP POST - so you can drive displays FrameOS has never heard of. Anything that can receive an image over the network becomes a FrameOS frame: custom microcontroller displays, digital signage players, other servers, you name it. ## How it works [#how-it-works] The frame renders your [scene](/guide/scenes) on its normal schedule. Instead of talking to a panel over SPI or HDMI, the driver POSTs the rendered PNG to the endpoint you configure in the frame's settings. Your receiver decides what to do with it. ## Setup [#setup] 1. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **HTTP upload** driver. 2. Set the width and height to match your target display, and configure the upload URL. 3. Save & deploy. Each render is delivered to your endpoint. ## Status [#status] 🟢 **Confirmed working** - tested on real hardware by the maintainers or the community. # Device database (/devices) FrameOS ships with **110+ display drivers**, selectable when you add a frame in the backend. Native Nim drivers cover most e-ink panels by **Waveshare** and **Pimoroni**, three generic drivers cover everything with a video output - and every display below has its own page with full specs and setup instructions. ## How the drivers work [#how-the-drivers-work] * **E-ink panels** are driven over SPI by drivers compiled directly into the FrameOS binary - no Python, no vendor libraries. FrameOS renders your [scene](/guide/scenes), dithers it to the panel's exact ink palette, and pushes the result to the display. * **[HDMI / Framebuffer](/devices/framebuffer-hdmi)** renders straight to the Pi's video output - TVs, monitors, any HDMI panel. On a Pi 5 it pushes 60 frames per second. * **[Web only](/devices/web-only)** runs a frame with no physical display: view it in the browser, perfect for trying FrameOS or kiosk setups. * **[HTTP upload](/devices/http-upload)** POSTs each rendered image to a URL of your choosing - drive displays FrameOS has never heard of. * Older or unusual **Pimoroni Inky** boards fall back to a [Python driver](/devices/pimoroni-inky-python) that auto-detects the panel. * Panels marked **ESP32** also work without a Raspberry Pi, driven by the [FrameOS ESP32-S3 firmware](/guide/esp32). ESP32 currently targets Waveshare SPI e-paper panels and headless builds; each firmware image contains one selected panel driver. ## Picking a panel [#picking-a-panel] New to e-ink? Start with the [Waveshare buying guide](/devices/waveshare-other-displays), or jump straight to a crowd favourite: the [Pimoroni Inky Impression 7.3"](/devices/pimoroni-inky-impression-7.3inch-eink) for plug-and-play color, or the [Waveshare 13.3" Spectra 6](/devices/waveshare-epd-13in3e) for a big, vivid art frame. ## Your panel is missing? [#your-panel-is-missing] * Displays not in this database: [open an issue](https://github.com/FrameOS/frameos/issues), or try the closest driver - controller boards are often shared between panels. * Tested a panel marked "should work"? [Tell us, with a photo](https://github.com/FrameOS/frameos/issues/65). * Each device page is a markdown file in [`content/docs/devices/`](https://github.com/FrameOS/frameos-docs/tree/main/content/docs/devices), so corrections and additions are one pull request away. # Pimoroni HyperPixel 2.1" round LCD (/devices/pimoroni-hyperpixel-2.1inch-round-480x480-lcd) * Manufacturer: [Pimoroni](https://shop.pimoroni.com/) * Device: [HyperPixel 2.1" Round 480×480 LCD with touch](https://shop.pimoroni.com/products/hyperpixel-round) * Extra: touch input ## What to buy [#what-to-buy] * The HyperPixel 2.1" Round display from Pimoroni. * A Raspberry Pi Zero 2 W (preferred) or Zero W. * A 40-pin GPIO header to solder onto the Pi - or buy the pre-pinned Zero WH/W2H and skip the soldering. ## Setup [#setup] FrameOS has two drivers for this panel: * **Pimoroni HyperPixel 2.1 Round (native)** - try this first on current Raspberry Pi OS. * **Pimoroni HyperPixel 2.1 Round** - the legacy framebuffer driver, for the Bullseye-based setup below. For the legacy route, install **Raspberry Pi OS (Legacy) Lite - "Bullseye"**, then SSH in and run: ```bash sudo apt -y update sudo apt -y install git git clone https://github.com/pimoroni/hyperpixel2r cd hyperpixel2r sudo ./install.sh # remove 3d acceleration sudo sed -i '/dtoverlay=vc4-kms-v3d/s/^/#/' /boot/config.txt sudo reboot ``` After the reboot the screen shows the Linux boot log. Add the frame in the backend, pick the HyperPixel driver, and deploy. ## Brightness control [#brightness-control] The backlight is on BCM pin 19 (PWM): ```bash sudo apt install wiringpi gpio -g mode 19 pwm # set the pin to PWM mode gpio -g pwm 19 60 # 0-24 off, 25-90 dimmed, 91-1023 full brightness ``` ## 3D models [#3d-models] A community case design is available [on Cults3D](https://cults3d.com/en/3d-model/gadget/enclosure-m3-for-pimoroni-hyperpixel-2-1-round-touch-and-raspberry-pi-zeer.imaero). # Pimoroni Inky Impression 13.3" (2025 / Spectra 6) (/devices/pimoroni-inky-impression-13-2025) The **Pimoroni Inky Impression 13.3" (2025 / Spectra 6)** is a 13.3″ e-ink panel with a resolution of **1600×1200 pixels** showing **six Spectra 6 ink colors**. Spectra 6 is the current generation of color e-ink: six vivid ink colors with much better saturation than the older 7-color ACeP panels. A full refresh takes roughly 15-30 seconds. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. The four side buttons are registered automatically and can trigger events in your [scenes](/guide/scenes) - switch scenes, cycle images, anything. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_impression_13`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky Impression - 13.3" 2025 edition** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky Impression 4.0" (2025 / Spectra 6) (/devices/pimoroni-inky-impression-4-2025) The **Pimoroni Inky Impression 4.0" (2025 / Spectra 6)** is a 4″ e-ink panel with a resolution of **600×400 pixels** showing **six Spectra 6 ink colors**. Spectra 6 is the current generation of color e-ink: six vivid ink colors with much better saturation than the older 7-color ACeP panels. A full refresh takes roughly 15-30 seconds. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. The four side buttons are registered automatically and can trigger events in your [scenes](/guide/scenes) - switch scenes, cycle images, anything. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_impression_4_2025`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky Impression - 4.0" 2025 edition** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky Impression 4.0" (7-colour) (/devices/pimoroni-inky-impression-4-7-color) The **Pimoroni Inky Impression 4.0" (7-colour)** is a 4″ e-ink panel with a resolution of **640×400 pixels** showing **seven ACeP ink colors**. ACeP ("Advanced Color ePaper") packs seven real ink colors into every pixel. A full refresh takes around 30 seconds, and the palette is softer than a backlit screen - ideal for photos and generative art with a paper-like look. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. The four side buttons are registered automatically and can trigger events in your [scenes](/guide/scenes) - switch scenes, cycle images, anything. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_impression_4_7_color`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky Impression - 4.0" 7-colour** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky Impression 5.7" 7-colour (/devices/pimoroni-inky-impression-5.7inch-eink) * Manufacturer: [Pimoroni](https://shop.pimoroni.com/) * Device: [Inky Impression 5.7"](https://shop.pimoroni.com/products/inky-impression-5-7?variant=32298701324371) * Extra: 4 physical buttons (usable as scene event triggers in FrameOS) The Inky Impression line is the easiest e-ink hardware to start with: the panel comes glued to a HAT that plugs straight onto the Pi's GPIO header. No soldering, no separate driver board. ## Setup [#setup] 1. Plug the HAT onto the Pi, flash the SD card, [add the frame](/guide/first-deploy) in the backend. 2. Select the **Pimoroni Inky Impression - 5.7" 7-colour** driver. 3. Save & deploy. The display blinks through its refresh cycle and shows your scene. Recent Inky Impression models have native Nim drivers in FrameOS (fast, no extra dependencies). Older or unusual Inky models can use the **Python driver** fallback, which installs Pimoroni's Python library during the first deploy. The four side buttons are registered automatically and can trigger events in your scenes - switch scenes, cycle images, anything. # Pimoroni Inky Impression 7.3" (2025 / Spectra 6) (/devices/pimoroni-inky-impression-7-2025) The **Pimoroni Inky Impression 7.3" (2025 / Spectra 6)** is a 7.3″ e-ink panel with a resolution of **800×480 pixels** showing **six Spectra 6 ink colors**. Spectra 6 is the current generation of color e-ink: six vivid ink colors with much better saturation than the older 7-color ACeP panels. A full refresh takes roughly 15-30 seconds. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. The four side buttons are registered automatically and can trigger events in your [scenes](/guide/scenes) - switch scenes, cycle images, anything. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_impression_7`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky Impression - 7.3" 2025 edition** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky Impression 7.3" 7-colour (/devices/pimoroni-inky-impression-7.3inch-eink) * Manufacturer: [Pimoroni](https://shop.pimoroni.com/) * Device: [Inky Impression 7.3"](https://shop.pimoroni.com/products/inky-impression-7-3) * Extra: 4 physical buttons (usable as scene event triggers in FrameOS) Like its 5.7" sibling, the 7.3" Inky Impression is plug-and-play: panel and driver board are one unit that slots onto the GPIO header. Both the original 7-colour version and the **2025 Spectra 6 edition** are supported with native drivers - there's even a driver for the 13.3" 2025 edition. ## Setup [#setup] 1. Plug the HAT onto the Pi, flash the SD card, [add the frame](/guide/first-deploy) in the backend. 2. Select the matching **Pimoroni Inky Impression 7.3"** driver (original or 2025 edition). 3. Save & deploy. The display blinks through its refresh cycle and shows your scene. For a full build walkthrough - including 3D-printed cases for these panels - watch the [Spectra 6 build video](/blog/eink-spectra-waveshare-pimoroni). # Pimoroni Inky Impression - other models (Python driver) (/devices/pimoroni-inky-impression-python) The **Pimoroni Inky Impression - other models (Python driver)** driver is a catch-all for Inky panels that don't have a dedicated native driver in FrameOS. It uses [Pimoroni's official Python library](https://github.com/pimoroni/inky), which auto-detects most Inky boards via the EEPROM on the HAT. ## How it works [#how-it-works] On the first deploy, FrameOS installs the Inky Python library on the Raspberry Pi and renders through a small helper process. This is slower to deploy and uses a bit more memory than the native Nim drivers, but it supports every panel the official library supports - resolution and colors are detected from the board itself. If your panel has a dedicated entry in the [device database](/devices), prefer that driver. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky Impression - all others (Python driver)** driver. 3. Save & deploy. The first deploy takes longer while the Python dependencies install. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky pHAT 2.13" (4-colour) (/devices/pimoroni-inky-phat-4) The **Pimoroni Inky pHAT 2.13" (4-colour)** is a 2.13″ e-ink panel with a resolution of **250×122 pixels** showing **black, white, yellow and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_phat_4`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky pHAT - 2.13" 4-colour** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky pHAT 2.13" black/white (/devices/pimoroni-inky-phat-black) The **Pimoroni Inky pHAT 2.13" black/white** is a 2.13″ e-ink panel with a resolution of **212×104 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_phat_black`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky pHAT - 2.13" black/white** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky pHAT 2.13" black/white/red (high-temp) (/devices/pimoroni-inky-phat-red-ht) The **Pimoroni Inky pHAT 2.13" black/white/red (high-temp)** is a 2.13″ e-ink panel with a resolution of **212×104 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_phat_red_ht`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky pHAT - 2.13" black/white/red high-temp** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky pHAT 2.13" black/white/red (/devices/pimoroni-inky-phat-red) The **Pimoroni Inky pHAT 2.13" black/white/red** is a 2.13″ e-ink panel with a resolution of **212×104 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_phat_red`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky pHAT - 2.13" black/white/red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky pHAT 2.13" black/white (SSD1608) (/devices/pimoroni-inky-phat-ssd1608-black) The **Pimoroni Inky pHAT 2.13" black/white (SSD1608)** is a 2.13″ e-ink panel with a resolution of **250×122 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_phat_ssd1608_black`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky pHAT - 2.13" black/white (SSD1608)** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky pHAT 2.13" black/white/red (SSD1608) (/devices/pimoroni-inky-phat-ssd1608-red) The **Pimoroni Inky pHAT 2.13" black/white/red (SSD1608)** is a 2.13″ e-ink panel with a resolution of **250×122 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_phat_ssd1608_red`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky pHAT - 2.13" black/white/red (SSD1608)** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky pHAT 2.13" black/white/yellow (SSD1608) (/devices/pimoroni-inky-phat-ssd1608-yellow) The **Pimoroni Inky pHAT 2.13" black/white/yellow (SSD1608)** is a 2.13″ e-ink panel with a resolution of **250×122 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_phat_ssd1608_yellow`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky pHAT - 2.13" black/white/yellow (SSD1608)** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky pHAT 2.13" black/white/yellow (/devices/pimoroni-inky-phat-yellow) The **Pimoroni Inky pHAT 2.13" black/white/yellow** is a 2.13″ e-ink panel with a resolution of **212×104 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_phat_yellow`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky pHAT - 2.13" black/white/yellow** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟢 **Confirmed working** - tested on real hardware by the maintainers or the community. # Pimoroni Inky - other models (Python driver) (/devices/pimoroni-inky-python) The **Pimoroni Inky - other models (Python driver)** driver is a catch-all for Inky panels that don't have a dedicated native driver in FrameOS. It uses [Pimoroni's official Python library](https://github.com/pimoroni/inky), which auto-detects most Inky boards via the EEPROM on the HAT. ## How it works [#how-it-works] On the first deploy, FrameOS installs the Inky Python library on the Raspberry Pi and renders through a small helper process. This is slower to deploy and uses a bit more memory than the native Nim drivers, but it supports every panel the official library supports - resolution and colors are detected from the board itself. If your panel has a dedicated entry in the [device database](/devices), prefer that driver. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky other (Python driver)** driver. 3. Save & deploy. The first deploy takes longer while the Python dependencies install. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky wHAT 4.2" (4-colour) (/devices/pimoroni-inky-what-4) The **Pimoroni Inky wHAT 4.2" (4-colour)** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **black, white, yellow and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_what_4`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky wHAT - 4.2" 4-colour** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky wHAT 4.2" black/white (/devices/pimoroni-inky-what-black) The **Pimoroni Inky wHAT 4.2" black/white** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_what_black`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky wHAT - 4.2" black/white** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky wHAT 4.2" black/white/red (high-temp) (/devices/pimoroni-inky-what-red-ht) The **Pimoroni Inky wHAT 4.2" black/white/red (high-temp)** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_what_red_ht`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky wHAT - 4.2" black/white/red high-temp** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky wHAT 4.2" black/white/red (/devices/pimoroni-inky-what-red) The **Pimoroni Inky wHAT 4.2" black/white/red** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_what_red`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky wHAT - 4.2" black/white/red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky wHAT 4.2" black/white (SSD1683) (/devices/pimoroni-inky-what-ssd1683-black) The **Pimoroni Inky wHAT 4.2" black/white (SSD1683)** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_what_ssd1683_black`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky wHAT - 4.2" black/white (SSD1683)** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky wHAT 4.2" black/white/red (SSD1683) (/devices/pimoroni-inky-what-ssd1683-red) The **Pimoroni Inky wHAT 4.2" black/white/red (SSD1683)** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_what_ssd1683_red`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky wHAT - 4.2" black/white/red (SSD1683)** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky wHAT 4.2" black/white/yellow (SSD1683) (/devices/pimoroni-inky-what-ssd1683-yellow) The **Pimoroni Inky wHAT 4.2" black/white/yellow (SSD1683)** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_what_ssd1683_yellow`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky wHAT - 4.2" black/white/yellow (SSD1683)** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Pimoroni Inky wHAT 4.2" black/white/yellow (/devices/pimoroni-inky-what-yellow) The **Pimoroni Inky wHAT 4.2" black/white/yellow** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Pimoroni's boards are the easiest e-ink hardware to start with: panel and driver electronics come as one unit that plugs straight onto the Pi's GPIO header - no soldering, no separate driver board. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/inky) (`pimoroni.inky_what_yellow`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Plug the board onto the Pi's GPIO header. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Pimoroni Inky wHAT - 4.2" black/white/yellow** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.13" 250×122 e-Paper (/devices/waveshare-2.13inch-250x122-epaper) * Device: [Waveshare 2.13" e-Paper HAT](https://www.waveshare.com/2.13inch-Touch-e-Paper-HAT.htm?\&aff_id=79380) Several hardware revisions exist (V2, V3, V4, plus 3-color and 4-color "G" variants) - they all have drivers in FrameOS. If you're not sure which revision you have, try the V4 driver first and work backwards until the image looks right. # Waveshare 5" round 1080×1080 LCD (/devices/waveshare-5inch-round-1080x1080-lcd) * Device: [Waveshare 5" round 1080×1080 LCD](https://www.waveshare.com/5inch-1080x1080-lcd.htm?\&aff_id=79380) ([wiki](https://www.waveshare.com/wiki/5inch_1080x1080_LCD)) * Driver: [HDMI / Framebuffer](/devices/framebuffer-hdmi) This display connects over HDMI, so it uses the framebuffer driver. It needs custom HDMI timings: add the following to the end of `/boot/config.txt` and reboot: ```ini hdmi_group=2 hdmi_mode=87 hdmi_pixel_freq_limit=356000000 hdmi_timings=1080 0 68 32 100 1080 0 12 4 16 0 0 0 60 0 85500000 0 ``` ## Power control [#power-control] Enable the Fake KMS driver: ```bash sudo sed -i '/dtoverlay=vc4-kms-v3d/s/kms/fkms/' /boot/config.txt ``` Then toggle the display from the command line: ```bash vcgencmd display_power 0 # off vcgencmd display_power 1 # on vcgencmd display_power | grep "display_power=0" >/dev/null && echo "off" || echo "on" ``` # Waveshare 7.5" 800×480 e-Paper (/devices/waveshare-7.5inch-800x480-epaper) * Device: [Waveshare 7.5" e-Paper HAT](https://www.waveshare.com/7.5inch-e-Paper-HAT.htm?\&aff_id=79380) * Variants: black/white (V2), black/white/red (B V2) A popular, affordable starter panel. The HAT plugs directly onto the Pi's GPIO header - or connect the included adapter board with the supplied cable. ## Setup [#setup] 1. Connect the panel to the Pi. 2. Select the matching **Waveshare 7.5"** driver variant when adding the frame (V2 for current black/white panels, B V2 for the 3-color version). 3. Save & deploy. The display will blink through its refresh cycle and show your scene. If the image looks wrong, try the other 7.5" driver variants - Waveshare has shipped several revisions under the same product name. ## ESP32 support [#esp32-support] This panel is supported by the [FrameOS ESP32 firmware](/guide/esp32): wire it to an ESP32-S3 over SPI, flash from the browser, and scenes render on the microcontroller itself - with over-the-air updates and an optional deep-sleep battery mode. Pick the exact Waveshare 7.5" driver variant when building firmware; each ESP32 image contains one selected panel driver. # Waveshare 10.2" (B) e-Paper (/devices/waveshare-epd-10in2b) The **Waveshare 10.2" (B) e-Paper** is a 10.2″ e-ink panel with a resolution of **960×640 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_10in2b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 10.2" (B) 960x640 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 10.3" e-Paper (/devices/waveshare-epd-10in3) The **Waveshare 10.3" e-Paper** is a 10.3″ e-ink panel with a resolution of **1872×1404 pixels** showing **16-level grayscale**. Grayscale e-ink renders dithered photos noticeably better than pure black-and-white panels, while keeping a quick refresh. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. This panel is driven through the IT8951 controller board (USB/SPI). It works, but draws more power than typical SPI panels. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_10in3`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 10.3" 1872x1404 16 Grayscale** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟢 **Confirmed working** - tested on real hardware by the maintainers or the community. # Waveshare 12.48" e-Paper (/devices/waveshare-epd-12in48) The **Waveshare 12.48" e-Paper** is a 12.48″ e-ink panel with a resolution of **1304×984 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. The 12.48" panel uses two driver boards and its own wiring - follow [the 12.48" build video](/blog/frameos-2024) for assembly. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_12in48`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 12.48" 1304x984 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 12.48" (B V2) e-Paper (/devices/waveshare-epd-12in48b-v2) The **Waveshare 12.48" (B V2) e-Paper** is a 12.48″ e-ink panel with a resolution of **1304×984 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. The 12.48" panel uses two driver boards and its own wiring - follow [the 12.48" build video](/blog/frameos-2024) for assembly. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_12in48b_V2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 12.48" (B V2) 1304x984 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟢 **Confirmed working** - tested on real hardware by the maintainers or the community. # Waveshare 12.48" (B) e-Paper (/devices/waveshare-epd-12in48b) The **Waveshare 12.48" (B) e-Paper** is a 12.48″ e-ink panel with a resolution of **1304×984 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. The 12.48" panel uses two driver boards and its own wiring - follow [the 12.48" build video](/blog/frameos-2024) for assembly. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_12in48b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 12.48" (B) 1304x984 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟢 **Confirmed working** - tested on real hardware by the maintainers or the community. # Waveshare 13.3" (B) e-Paper (/devices/waveshare-epd-13in3b) The **Waveshare 13.3" (B) e-Paper** is a 13.3″ e-ink panel with a resolution of **960×680 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_13in3b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 13.3" (B) 960x680 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 13.3" (E) e-Paper (/devices/waveshare-epd-13in3e) The **Waveshare 13.3" (E) e-Paper** is a 13.3″ e-ink panel with a resolution of **1600×1200 pixels** showing **six Spectra 6 ink colors**. Spectra 6 is the current generation of color e-ink: six vivid ink colors with much better saturation than the older 7-color ACeP panels. A full refresh takes roughly 15-30 seconds. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. See the [Spectra 6 build video](/blog/eink-spectra-waveshare-pimoroni) for a side-by-side look at color e-ink generations. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_13in3e`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 13.3" (E) 1600x1200 Spectra 6 Color** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟢 **Confirmed working** - tested on real hardware by the maintainers or the community. # Waveshare 13.3" (K) e-Paper (/devices/waveshare-epd-13in3k) The **Waveshare 13.3" (K) e-Paper** is a 13.3″ e-ink panel with a resolution of **960×680 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_13in3k`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 13.3" (K) 960x680 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 1.02" (D) e-Paper (/devices/waveshare-epd-1in02d) The **Waveshare 1.02" (D) e-Paper** is a 1.02″ e-ink panel with a resolution of **128×80 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_1in02d`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 1.02" (D) 128x80 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 1.54" (DES) e-Paper (/devices/waveshare-epd-1in54-des) The **Waveshare 1.54" (DES) e-Paper** is a 1.54″ e-ink panel with a resolution of **152×152 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_1in54_DES`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 1.54" (DES) 152x152 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 1.54" (V2) e-Paper (/devices/waveshare-epd-1in54-v2) The **Waveshare 1.54" (V2) e-Paper** is a 1.54″ e-ink panel with a resolution of **200×200 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_1in54_V2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 1.54" (V2) 200x200 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 1.54" e-Paper (/devices/waveshare-epd-1in54) The **Waveshare 1.54" e-Paper** is a 1.54″ e-ink panel with a resolution of **200×200 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_1in54`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 1.54" 200x200 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 1.54" (B V2) e-Paper (/devices/waveshare-epd-1in54b-v2) The **Waveshare 1.54" (B V2) e-Paper** is a 1.54″ e-ink panel with a resolution of **200×200 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_1in54b_V2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 1.54" (B V2) 200x200 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 1.54" (B) e-Paper (/devices/waveshare-epd-1in54b) The **Waveshare 1.54" (B) e-Paper** is a 1.54″ e-ink panel with a resolution of **200×200 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_1in54b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 1.54" (B) 200x200 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 1.54" (C) e-Paper (/devices/waveshare-epd-1in54c) The **Waveshare 1.54" (C) e-Paper** is a 1.54″ e-ink panel with a resolution of **152×152 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_1in54c`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 1.54" (C) 152x152 Black/White/Yellow** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 1.64" (G) e-Paper (/devices/waveshare-epd-1in64g) The **Waveshare 1.64" (G) e-Paper** is a 1.64″ e-ink panel with a resolution of **168×168 pixels** showing **black, white, yellow and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_1in64g`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 1.64" (G) 168x168 Black/White/Yellow/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.13" (DES) e-Paper (/devices/waveshare-epd-2in13-des) The **Waveshare 2.13" (DES) e-Paper** is a 2.13″ e-ink panel with a resolution of **212×104 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in13_DES`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.13" (DES) 212x104 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.13" (V2) e-Paper (/devices/waveshare-epd-2in13-v2) The **Waveshare 2.13" (V2) e-Paper** is a 2.13″ e-ink panel with a resolution of **250×122 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in13_V2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.13" (V2) 250x122 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.13" (V3) e-Paper (/devices/waveshare-epd-2in13-v3) The **Waveshare 2.13" (V3) e-Paper** is a 2.13″ e-ink panel with a resolution of **250×122 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in13_V3`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.13" (V3) 250x122 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.13" e-Paper (/devices/waveshare-epd-2in13) The **Waveshare 2.13" e-Paper** is a 2.13″ e-ink panel with a resolution of **250×122 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in13`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.13" 250x122 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟢 **Confirmed working** - tested on real hardware by the maintainers or the community. # Waveshare 2.13" (B V3) e-Paper (/devices/waveshare-epd-2in13b-v3) The **Waveshare 2.13" (B V3) e-Paper** is a 2.13″ e-ink panel with a resolution of **212×104 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in13b_V3`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.13" (B V3) 212x104 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.13" (B V4) e-Paper (/devices/waveshare-epd-2in13b-v4) The **Waveshare 2.13" (B V4) e-Paper** is a 2.13″ e-ink panel with a resolution of **250×122 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in13b_V4`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.13" (B V4) 250x122 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.13" (B) e-Paper (/devices/waveshare-epd-2in13b) The **Waveshare 2.13" (B) e-Paper** is a 2.13″ e-ink panel with a resolution of **212×104 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in13b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.13" (B) 212x104 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.13" (BC) e-Paper (/devices/waveshare-epd-2in13bc) The **Waveshare 2.13" (BC) e-Paper** is a 2.13″ e-ink panel with a resolution of **212×104 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in13bc`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.13" (BC) 212x104 Black/White/Yellow** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.13" (C) e-Paper (/devices/waveshare-epd-2in13c) The **Waveshare 2.13" (C) e-Paper** is a 2.13″ e-ink panel with a resolution of **212×104 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in13c`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.13" (C) 212x104 Black/White/Yellow** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.13" (D) e-Paper (/devices/waveshare-epd-2in13d) The **Waveshare 2.13" (D) e-Paper** is a 2.13″ e-ink panel with a resolution of **212×104 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in13d`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.13" (D) 212x104 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.13" (G V2) e-Paper (/devices/waveshare-epd-2in13g-v2) The **Waveshare 2.13" (G V2) e-Paper** is a 2.13″ e-ink panel with a resolution of **250×122 pixels** showing **black, white, yellow and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in13g_V2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.13" (G V2) 250x122 Black/White/Yellow/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.13" (G) e-Paper (/devices/waveshare-epd-2in13g) The **Waveshare 2.13" (G) e-Paper** is a 2.13″ e-ink panel with a resolution of **250×122 pixels** showing **black, white, yellow and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in13g`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.13" (G) 250x122 Black/White/Yellow/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.15" (B) e-Paper (/devices/waveshare-epd-2in15b) The **Waveshare 2.15" (B) e-Paper** is a 2.15″ e-ink panel with a resolution of **296×160 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in15b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.15" (B) 296x160 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.15" (G) e-Paper (/devices/waveshare-epd-2in15g) The **Waveshare 2.15" (G) e-Paper** is a 2.15″ e-ink panel with a resolution of **296×160 pixels** showing **black, white, yellow and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in15g`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.15" (G) 296x160 Black/White/Yellow/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.36" (G) e-Paper (/devices/waveshare-epd-2in36g) The **Waveshare 2.36" (G) e-Paper** is a 2.36″ e-ink panel with a resolution of **296×168 pixels** showing **black, white, yellow and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in36g`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.36" (G) 296x168 Black/White/Yellow/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.66" e-Paper (/devices/waveshare-epd-2in66) The **Waveshare 2.66" e-Paper** is a 2.66″ e-ink panel with a resolution of **296×152 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in66`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.66" 296x152 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.66" (B) e-Paper (/devices/waveshare-epd-2in66b) The **Waveshare 2.66" (B) e-Paper** is a 2.66″ e-ink panel with a resolution of **296×152 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in66b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.66" (B) 296x152 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.66" (G) e-Paper (/devices/waveshare-epd-2in66g) The **Waveshare 2.66" (G) e-Paper** is a 2.66″ e-ink panel with a resolution of **360×184 pixels** showing **black, white, yellow and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in66g`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.66" (G) 360x184 Black/White/Yellow/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.7" (V2) e-Paper (/devices/waveshare-epd-2in7-v2) The **Waveshare 2.7" (V2) e-Paper** is a 2.7″ e-ink panel with a resolution of **264×176 pixels** showing **4-level grayscale**. Grayscale e-ink renders dithered photos noticeably better than pure black-and-white panels, while keeping a quick refresh. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in7_V2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.7" (V2) 264x176 4 Grayscale** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.7" e-Paper (/devices/waveshare-epd-2in7) The **Waveshare 2.7" e-Paper** is a 2.7″ e-ink panel with a resolution of **264×176 pixels** showing **4-level grayscale**. Grayscale e-ink renders dithered photos noticeably better than pure black-and-white panels, while keeping a quick refresh. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in7`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.7" 264x176 4 Grayscale** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.7" (B V2) e-Paper (/devices/waveshare-epd-2in7b-v2) The **Waveshare 2.7" (B V2) e-Paper** is a 2.7″ e-ink panel with a resolution of **264×176 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in7b_V2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.7" (B V2) 264x176 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.7" (B) e-Paper (/devices/waveshare-epd-2in7b) The **Waveshare 2.7" (B) e-Paper** is a 2.7″ e-ink panel with a resolution of **264×176 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in7b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.7" (B) 264x176 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.9" (DES) e-Paper (/devices/waveshare-epd-2in9-des) The **Waveshare 2.9" (DES) e-Paper** is a 2.9″ e-ink panel with a resolution of **296×128 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in9_DES`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.9" (DES) 296x128 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.9" (V2) e-Paper (/devices/waveshare-epd-2in9-v2) The **Waveshare 2.9" (V2) e-Paper** is a 2.9″ e-ink panel with a resolution of **296×128 pixels** showing **4-level grayscale**. Grayscale e-ink renders dithered photos noticeably better than pure black-and-white panels, while keeping a quick refresh. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in9_V2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.9" (V2) 296x128 4 Grayscale** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.9" e-Paper (/devices/waveshare-epd-2in9) The **Waveshare 2.9" e-Paper** is a 2.9″ e-ink panel with a resolution of **296×128 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in9`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.9" 296x128 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.9" (B V3) e-Paper (/devices/waveshare-epd-2in9b-v3) The **Waveshare 2.9" (B V3) e-Paper** is a 2.9″ e-ink panel with a resolution of **296×128 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in9b_V3`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.9" (B V3) 296x128 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.9" (B V4) e-Paper (/devices/waveshare-epd-2in9b-v4) The **Waveshare 2.9" (B V4) e-Paper** is a 2.9″ e-ink panel with a resolution of **296×128 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in9b_V4`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.9" (B V4) 296x128 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.9" (B) e-Paper (/devices/waveshare-epd-2in9b) The **Waveshare 2.9" (B) e-Paper** is a 2.9″ e-ink panel with a resolution of **296×128 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in9b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.9" (B) 296x128 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.9" (BC) e-Paper (/devices/waveshare-epd-2in9bc) The **Waveshare 2.9" (BC) e-Paper** is a 2.9″ e-ink panel with a resolution of **296×128 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in9bc`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.9" (BC) 296x128 Black/White/Yellow** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.9" (C) e-Paper (/devices/waveshare-epd-2in9c) The **Waveshare 2.9" (C) e-Paper** is a 2.9″ e-ink panel with a resolution of **296×128 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in9c`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.9" (C) 296x128 Black/White/Yellow** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 2.9" (D) e-Paper (/devices/waveshare-epd-2in9d) The **Waveshare 2.9" (D) e-Paper** is a 2.9″ e-ink panel with a resolution of **296×128 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_2in9d`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 2.9" (D) 296x128 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 3" (G) e-Paper (/devices/waveshare-epd-3in0g) The **Waveshare 3" (G) e-Paper** is a 3″ e-ink panel with a resolution of **400×168 pixels** showing **black, white, yellow and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_3in0g`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 3" (G) 400x168 Black/White/Yellow/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 3.52" e-Paper (/devices/waveshare-epd-3in52) The **Waveshare 3.52" e-Paper** is a 3.52″ e-ink panel with a resolution of **360×240 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_3in52`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 3.52" 360x240 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 3.52" (B) e-Paper (/devices/waveshare-epd-3in52b) The **Waveshare 3.52" (B) e-Paper** is a 3.52″ e-ink panel with a resolution of **360×240 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_3in52b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 3.52" (B) 360x240 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 3.7" e-Paper (/devices/waveshare-epd-3in7) The **Waveshare 3.7" e-Paper** is a 3.7″ e-ink panel with a resolution of **480×280 pixels** showing **4-level grayscale**. Grayscale e-ink renders dithered photos noticeably better than pure black-and-white panels, while keeping a quick refresh. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_3in7`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 3.7" 480x280 4 Grayscale** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 4.01" (F) e-Paper (/devices/waveshare-epd-4in01f) The **Waveshare 4.01" (F) e-Paper** is a 4.01″ e-ink panel with a resolution of **640×400 pixels** showing **seven ACeP ink colors**. ACeP ("Advanced Color ePaper") packs seven real ink colors into every pixel. A full refresh takes around 30 seconds, and the palette is softer than a backlit screen - ideal for photos and generative art with a paper-like look. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. See the [Spectra 6 build video](/blog/eink-spectra-waveshare-pimoroni) for a side-by-side look at color e-ink generations. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_4in01f`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 4.01" (F) 640x400 7 Color** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟢 **Confirmed working** - tested on real hardware by the maintainers or the community. # Waveshare 4" (E) e-Paper (/devices/waveshare-epd-4in0e) The **Waveshare 4" (E) e-Paper** is a 4″ e-ink panel with a resolution of **600×400 pixels** showing **six Spectra 6 ink colors**. Spectra 6 is the current generation of color e-ink: six vivid ink colors with much better saturation than the older 7-color ACeP panels. A full refresh takes roughly 15-30 seconds. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. See the [Spectra 6 build video](/blog/eink-spectra-waveshare-pimoroni) for a side-by-side look at color e-ink generations. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_4in0e`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 4" (E) 600x400 Spectra 6 Color** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟢 **Confirmed working** - tested on real hardware by the maintainers or the community. # Waveshare 4.2" (V2) e-Paper (/devices/waveshare-epd-4in2-v2) The **Waveshare 4.2" (V2) e-Paper** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **4-level grayscale**. Grayscale e-ink renders dithered photos noticeably better than pure black-and-white panels, while keeping a quick refresh. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_4in2_V2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 4.2" (V2) 400x300 4 Grayscale** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 4.2" e-Paper (/devices/waveshare-epd-4in2) The **Waveshare 4.2" e-Paper** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **4-level grayscale**. Grayscale e-ink renders dithered photos noticeably better than pure black-and-white panels, while keeping a quick refresh. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_4in2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 4.2" 400x300 4 Grayscale** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 4.26" e-Paper (/devices/waveshare-epd-4in26) The **Waveshare 4.26" e-Paper** is a 4.26″ e-ink panel with a resolution of **800×480 pixels** showing **4-level grayscale**. Grayscale e-ink renders dithered photos noticeably better than pure black-and-white panels, while keeping a quick refresh. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_4in26`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 4.26" 800x480 4 Grayscale** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 4.2" (B V2 OLD) e-Paper (/devices/waveshare-epd-4in2b-v2-old) The **Waveshare 4.2" (B V2 OLD) e-Paper** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_4in2b_V2_old`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 4.2" (B V2 OLD) 400x300 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 4.2" (B V2) e-Paper (/devices/waveshare-epd-4in2b-v2) The **Waveshare 4.2" (B V2) e-Paper** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_4in2b_V2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 4.2" (B V2) 400x300 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 4.2" (B) e-Paper (/devices/waveshare-epd-4in2b) The **Waveshare 4.2" (B) e-Paper** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_4in2b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 4.2" (B) 400x300 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 4.2" (BC) e-Paper (/devices/waveshare-epd-4in2bc) The **Waveshare 4.2" (BC) e-Paper** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_4in2bc`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 4.2" (BC) 400x300 Black/White/Yellow** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 4.2" (C) e-Paper (/devices/waveshare-epd-4in2c) The **Waveshare 4.2" (C) e-Paper** is a 4.2″ e-ink panel with a resolution of **400×300 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_4in2c`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 4.2" (C) 400x300 Black/White/Yellow** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 4.37" (B) e-Paper (/devices/waveshare-epd-4in37b) The **Waveshare 4.37" (B) e-Paper** is a 4.37″ e-ink panel with a resolution of **480×176 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_4in37b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 4.37" (B) 480x176 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 4.37" (G) e-Paper (/devices/waveshare-epd-4in37g) The **Waveshare 4.37" (G) e-Paper** is a 4.37″ e-ink panel with a resolution of **512×368 pixels** showing **black, white, yellow and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_4in37g`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 4.37" (G) 512x368 Black/White/Yellow/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 5.65" (F) e-Paper (/devices/waveshare-epd-5in65f) The **Waveshare 5.65" (F) e-Paper** is a 5.65″ e-ink panel with a resolution of **600×448 pixels** showing **seven ACeP ink colors**. ACeP ("Advanced Color ePaper") packs seven real ink colors into every pixel. A full refresh takes around 30 seconds, and the palette is softer than a backlit screen - ideal for photos and generative art with a paper-like look. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. See the [Spectra 6 build video](/blog/eink-spectra-waveshare-pimoroni) for a side-by-side look at color e-ink generations. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_5in65f`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 5.65" (F) 600x448 7 Color** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 5.79" e-Paper (/devices/waveshare-epd-5in79) The **Waveshare 5.79" e-Paper** is a 5.79″ e-ink panel with a resolution of **792×272 pixels** showing **4-level grayscale**. Grayscale e-ink renders dithered photos noticeably better than pure black-and-white panels, while keeping a quick refresh. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_5in79`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 5.79" 792x272 4 Grayscale** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 5.79" (B) e-Paper (/devices/waveshare-epd-5in79b) The **Waveshare 5.79" (B) e-Paper** is a 5.79″ e-ink panel with a resolution of **792×272 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_5in79b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 5.79" (B) 792x272 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 5.79" (G) e-Paper (/devices/waveshare-epd-5in79g) The **Waveshare 5.79" (G) e-Paper** is a 5.79″ e-ink panel with a resolution of **792×272 pixels** showing **black, white, yellow and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_5in79g`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 5.79" (G) 792x272 Black/White/Yellow/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 5.83" (V2) e-Paper (/devices/waveshare-epd-5in83-v2) The **Waveshare 5.83" (V2) e-Paper** is a 5.83″ e-ink panel with a resolution of **648×480 pixels** showing **4-level grayscale**. Grayscale e-ink renders dithered photos noticeably better than pure black-and-white panels, while keeping a quick refresh. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_5in83_V2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 5.83" (V2) 648x480 4 Grayscale** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 5.83" e-Paper (/devices/waveshare-epd-5in83) The **Waveshare 5.83" e-Paper** is a 5.83″ e-ink panel with a resolution of **600×448 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_5in83`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 5.83" 600x448 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 5.83" (B V2) e-Paper (/devices/waveshare-epd-5in83b-v2) The **Waveshare 5.83" (B V2) e-Paper** is a 5.83″ e-ink panel with a resolution of **648×480 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_5in83b_V2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 5.83" (B V2) 648x480 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 5.83" (B) e-Paper (/devices/waveshare-epd-5in83b) The **Waveshare 5.83" (B) e-Paper** is a 5.83″ e-ink panel with a resolution of **600×448 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_5in83b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 5.83" (B) 600x448 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 5.83" (BC) e-Paper (/devices/waveshare-epd-5in83bc) The **Waveshare 5.83" (BC) e-Paper** is a 5.83″ e-ink panel with a resolution of **600×448 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_5in83bc`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 5.83" (BC) 600x448 Black/White/Yellow** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 5.83" (C) e-Paper (/devices/waveshare-epd-5in83c) The **Waveshare 5.83" (C) e-Paper** is a 5.83″ e-ink panel with a resolution of **600×448 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_5in83c`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 5.83" (C) 600x448 Black/White/Yellow** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 5.84" e-Paper (/devices/waveshare-epd-5in84) The **Waveshare 5.84" e-Paper** is a 5.84″ e-ink panel with a resolution of **768×256 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_5in84`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 5.84" 768x256 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 7.3" (E) e-Paper (/devices/waveshare-epd-7in3e) The **Waveshare 7.3" (E) e-Paper** is a 7.3″ e-ink panel with a resolution of **800×480 pixels** showing **six Spectra 6 ink colors**. Spectra 6 is the current generation of color e-ink: six vivid ink colors with much better saturation than the older 7-color ACeP panels. A full refresh takes roughly 15-30 seconds. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. See the [Spectra 6 build video](/blog/eink-spectra-waveshare-pimoroni) for a side-by-side look at color e-ink generations. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_7in3e`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 7.3" (E) 800x480 Spectra 6 Color** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟢 **Confirmed working** - tested on real hardware by the maintainers or the community. # Waveshare 7.3" (F) e-Paper (/devices/waveshare-epd-7in3f) The **Waveshare 7.3" (F) e-Paper** is a 7.3″ e-ink panel with a resolution of **800×480 pixels** showing **seven ACeP ink colors**. ACeP ("Advanced Color ePaper") packs seven real ink colors into every pixel. A full refresh takes around 30 seconds, and the palette is softer than a backlit screen - ideal for photos and generative art with a paper-like look. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. See the [Spectra 6 build video](/blog/eink-spectra-waveshare-pimoroni) for a side-by-side look at color e-ink generations. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_7in3f`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 7.3" (F) 800x480 7 Color** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 7.3" (G) e-Paper (/devices/waveshare-epd-7in3g) The **Waveshare 7.3" (G) e-Paper** is a 7.3″ e-ink panel with a resolution of **800×480 pixels** showing **black, white, yellow and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_7in3g`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 7.3" (G) 800x480 Black/White/Yellow/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 7.5" (HD) e-Paper (/devices/waveshare-epd-7in5-hd) The **Waveshare 7.5" (HD) e-Paper** is a 7.5″ e-ink panel with a resolution of **880×528 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_7in5_HD`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 7.5" (HD) 880x528 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 7.5" (V2 GRAY) e-Paper (/devices/waveshare-epd-7in5-v2-gray) The **Waveshare 7.5" (V2 GRAY) e-Paper** is a 7.5″ e-ink panel with a resolution of **800×480 pixels** showing **4-level grayscale**. Grayscale e-ink renders dithered photos noticeably better than pure black-and-white panels, while keeping a quick refresh. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_7in5_V2_gray`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 7.5" (V2 GRAY) 800x480 4 Grayscale** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 7.5" e-Paper (/devices/waveshare-epd-7in5) The **Waveshare 7.5" e-Paper** is a 7.5″ e-ink panel with a resolution of **640×384 pixels** showing **black and white**. Two-tone e-ink has the fastest refresh of any e-paper type - a full update takes only a couple of seconds - and the high contrast works great for text, dashboards and dithered photos. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_7in5`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 7.5" 640x384 Black/White** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 7.5" (B HD) e-Paper (/devices/waveshare-epd-7in5b-hd) The **Waveshare 7.5" (B HD) e-Paper** is a 7.5″ e-ink panel with a resolution of **880×528 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_7in5b_HD`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 7.5" (B HD) 880x528 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 7.5" (B V2 OLD) e-Paper (/devices/waveshare-epd-7in5b-v2-old) The **Waveshare 7.5" (B V2 OLD) e-Paper** is a 7.5″ e-ink panel with a resolution of **800×480 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_7in5b_V2_old`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 7.5" (B V2 OLD) 800x480 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 7.5" (B V2) e-Paper (/devices/waveshare-epd-7in5b-v2) The **Waveshare 7.5" (B V2) e-Paper** is a 7.5″ e-ink panel with a resolution of **800×480 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_7in5b_V2`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 7.5" (B V2) 800x480 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟢 **Confirmed working** - tested on real hardware by the maintainers or the community. # Waveshare 7.5" (B) e-Paper (/devices/waveshare-epd-7in5b) The **Waveshare 7.5" (B) e-Paper** is a 7.5″ e-ink panel with a resolution of **640×384 pixels** showing **black, white and red**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_7in5b`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 7.5" (B) 640x384 Black/White/Red** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 7.5" (BC) e-Paper (/devices/waveshare-epd-7in5bc) The **Waveshare 7.5" (BC) e-Paper** is a 7.5″ e-ink panel with a resolution of **640×384 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_7in5bc`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 7.5" (BC) 640x384 Black/White/Yellow** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare 7.5" (C) e-Paper (/devices/waveshare-epd-7in5c) The **Waveshare 7.5" (C) e-Paper** is a 7.5″ e-ink panel with a resolution of **640×384 pixels** showing **black, white and yellow**. Panels with an accent ink run a multi-pass refresh that takes roughly 15-30 seconds, so they suit art, calendars and dashboards that update every few minutes rather than every second. Like all e-paper, it keeps the last image with zero power - the frame only wakes up to render. ## How it works [#how-it-works] FrameOS ships a [native Nim driver](https://github.com/FrameOS/frameos/tree/main/frameos/src/drivers/waveshare) (`waveshare.EPD_7in5c`) compiled straight into the binary that runs on your Raspberry Pi - no Python, no vendor libraries. Each render pass draws your [scene](/guide/scenes) into a full-color image, dithers it to the panel's palette, and pushes the result to the display over SPI. ## Setup [#setup] 1. Connect the panel to the Raspberry Pi - plug the HAT onto the GPIO header, or hook up the separate driver board with the bundled ribbon cable. 2. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Waveshare 7.5" (C) 640x384 Black/White/Yellow** driver. 3. Save & deploy. The panel blinks through a refresh cycle and shows your scene. Make sure the letter suffix on your panel's ribbon cable matches the driver - Waveshare reuses product names across revisions. More tips in the [Waveshare buying guide](/devices/waveshare-other-displays). ## Status [#status] 🟡 **Should work, not yet confirmed on real hardware.** The driver shares its controller logic with panels that are confirmed working. If you have this display, [report your results with a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it confirmed. # Waveshare buying guide (/devices/waveshare-other-displays) FrameOS has native Nim drivers for nearly a hundred Waveshare e-Paper variants - see the [device database](/devices). This page covers what's been verified on real hardware and a few buying tips. ## Tested on real hardware [#tested-on-real-hardware] * [Waveshare 13.3" (E)](/devices/waveshare-epd-13in3e) 1600×1200 **Spectra 6 color** * [Waveshare 7.3" (E)](/devices/waveshare-epd-7in3e) 800×480 **Spectra 6 color** * [Waveshare 4.0" (E)](/devices/waveshare-epd-4in0e) 600×400 **Spectra 6 color** * [Waveshare 4.01" (F)](/devices/waveshare-epd-4in01f) 640×400 7-color * [Waveshare 12.48" (B](/devices/waveshare-epd-12in48b) / [B V2)](/devices/waveshare-epd-12in48b-v2) 1304×984 black/white/red * [Waveshare 7.5" (V2)](/devices/waveshare-7.5inch-800x480-epaper) 800×480 black/white and [(B V2)](/devices/waveshare-epd-7in5b-v2) 3-color * [Waveshare 2.13"](/devices/waveshare-2.13inch-250x122-epaper) 250×122 black/white * [Waveshare 10.3"](/devices/waveshare-epd-10in3) 1872×1404 16-grayscale (IT8951 controller) Everything else in the [device database](/devices) shares controller logic with these and should work. If you confirm a panel, [post a photo](https://github.com/FrameOS/frameos/issues/65) and we'll mark it tested. ## Buying tips [#buying-tips] * **Spectra 6 (E) panels** are the current sweet spot for color e-ink: six real ink colors, much better saturation than the older 7-color (F) ACeP panels. The [build video](/blog/eink-spectra-waveshare-pimoroni) compares them side by side. * Waveshare panels usually arrive as a **bare glass panel plus a separate driver HAT** connected by a ribbon cable. That's more flexible for slim builds than Pimoroni's all-in-one HATs, but slightly more fiddly. Handle the glass with care. * Pay attention to the **letter suffix** (B, C, D, E, F, G, V2…) - it identifies the exact revision and the right driver. The label is printed on the panel's ribbon cable. * Driver picked but the image looks wrong? Try the neighbouring revisions of the same size - Waveshare reuses product names across hardware generations. ## Known quirks [#known-quirks] * The [12.48" panel](/devices/waveshare-epd-12in48b) uses two driver boards and its own wiring - follow [the 12.48" build video](/blog/frameos-2024) for assembly. * The [10.3" IT8951 panel](/devices/waveshare-epd-10in3) works but is grayscale-only and draws more power than SPI panels. # Web only (no physical display) (/devices/web-only) **Web only** runs a frame with no physical display attached. The frame renders your [scenes](/guide/scenes) on schedule, and you view the result in any browser - straight from the frame, or mirrored in the FrameOS backend. Great for: * Trying out FrameOS before any e-ink hardware arrives. * Kiosk setups where another machine fullscreens the frame's URL. * Debugging scenes without waiting for an e-ink refresh. The [ESP32 firmware](/guide/esp32) supports this mode too ("No display / headless") - handy for testing a board before the panel arrives. ## Setup [#setup] 1. [Add a frame](/guide/first-deploy) in the FrameOS backend and select the **Web only** driver. 2. Set any width and height you like - the canvas is fully RGB at whatever resolution you choose. 3. Save & deploy, then open the frame's URL in a browser. ## Status [#status] 🟢 **Confirmed working** - tested on real hardware by the maintainers or the community.