# ChannelOS vs Screenly and Anthias (formerly Screenly OSE): signage with no Pi to run

> An honest comparison of ChannelOS with Screenly and Anthias — the project formerly called Screenly OSE. Raspberry Pi self-hosting versus a TV browser, hand-made artwork versus AI-drafted shows, and who should stay put.

Source: https://channelos.tv/blog/channelos-vs-screenly-anthias
Published: 2026-07-24
Updated: 2026-07-28
Category: Comparison
Author: The ChannelOS team

**Screenly OSE is the open-source Raspberry Pi signage project that was renamed Anthias in 2022; Screenly is the commercial, hosted product it came from. Both put a small computer behind every TV, and Anthias asks you to maintain it. ChannelOS is the browser-based alternative for people who do not want to run a server or a fleet of Pis: pair a TV with no app and no player box, let AI draft the whole multi-slide show, and run every screen from one live board, with the first screen free. Self-hosters who want to own their hardware and data should stay on Anthias.**

---

Screenly OSE was, for the better part of a decade, the default answer to "how do I get something onto a screen with a Raspberry Pi". It was free, it was open source, it ran on a board that cost less than the HDMI cable, and it worked. In 2022 the project was renamed **Anthias**, and the two halves of the family went their separate ways: **Screenly** is the commercial, hosted, developer-facing product, and **Anthias** is the free, self-hosted, one-Pi-per-screen project it grew out of.

ChannelOS is for the person on the other side of the SD card: you want a board on the wall, not a fleet of small computers to keep alive. This is an honest look at where the three diverge — including the part where, if you like running your own hardware, you should stay exactly where you are.

## Screenly OSE, Anthias and Screenly: which is which

The naming trips people up, so it is worth being precise before comparing anything.

**Screenly OSE** was the open-source edition. You flashed it onto a Raspberry Pi, plugged the Pi into the TV, and managed that screen through a small web interface the device served on your own network. **Anthias** is that same project after its 2022 rename — same target hardware, same content model, still free, still open. **Screenly** is the commercial product: hosted management, a fleet console, an API and CLI, and Edge Apps, which let a developer ship an HTML and JavaScript app to the player rather than a flat file. It is billed per screen.

So a search for Screenly OSE today lands on Anthias, and the real choice is three-way: run Anthias yourself, pay Screenly to run it for you, or skip the player device entirely.

## What Anthias digital signage does well

Anthias digital signage earns its reputation, and the criticism below is worth nothing if the praise is not honest first.

**It costs nothing in software.** No per-screen fee, no seat count, no trial that expires. For a hobbyist, a makerspace, a school lab or anyone with more time than budget, that is decisive on its own.

**It plays offline.** Assets sit on the device's own storage, so a dropped connection does not blank the screen — it keeps looping what it already has. That is a real advantage a browser-based screen cannot match, and it is the single best reason to stay.

**You own everything.** The content is on hardware you can hold. The source is open, so you can read it, patch it, fork it or wire it into something else. Nobody can change the terms on you.

**The hardware is cheap and replaceable.** A Pi costs about what a month of most signage subscriptions does, and a dead one is swapped, not escalated to a vendor.

The costs are equally real. It is one small Linux computer per screen, and each one needs imaging, powering, mounting behind a wall-hung TV and patching. SD cards wear out, usually on the screen nobody walks past. There is no design tool at all — an asset is a finished image, video or web page, so the artwork happens somewhere else and Anthias only plays it. And the free edition manages screens one device at a time rather than as a wall, which is exactly the gap Screenly's commercial console fills.

## Getting a screen live

**Anthias:** image an SD card, boot a Pi, connect it to the network, find its address, open its web interface, upload your first asset.

**Screenly:** buy or supply a player, register it against your account, license it per screen.

**ChannelOS:** open one URL on the TV's own browser. It mints a screen and shows a code — scan it from your phone. no device to provision, no per-screen player to buy.

*Why it matters:* the gap between "I have a TV" and "it is showing my content" is minutes, not an afternoon with a card reader.

## Building a show

**Anthias and Screenly:** you bring finished artwork. An asset is an image, a video or a web-page URL with a duration; making it look good is a job you do in another tool first. Screenly's Edge Apps raise the ceiling considerably, but they raise it for developers — the answer to "I need a nicer menu board" is "write one".

**ChannelOS:** describe the show and AI drafts every slide — on-brand, multi-slide, editable. Hand it a PDF, an image or a webpage URL and it reads that for context. Then take it the last 10% in a Canva-style editor: free Pexels photos and video, one-tap background removal, tables, groups, and live widgets for clock, weather, QR, menu and ticker. If you would rather start from something finished, the [templates gallery](/templates) and the free [menu board maker](/tools/menu-board-maker) both hand you a board to edit.

*Why it matters:* most people do not have a designer, and "upload a PNG" quietly assumes one. Description-first creation means a first draft exists before you have made a single layout decision.

## Changing what's playing

**Anthias:** open the device's interface, change the asset list, and repeat for every other screen that shows the same thing.

**Screenly:** update the playlist centrally and let the players sync.

**ChannelOS:** edit once and it airs everywhere. What a screen shows is *derived* from the show and the channel schedule in real time, so there is no publish-and-wait step at all.

*Why it matters:* a wrong price on the lunch board is corrected on every screen the moment you save it, not the next time each device checks in.

## Running the wall

**Anthias:** each Pi is its own island with its own address and its own interface. Fleet management is the thing you buy Screenly for.

**ChannelOS:** one live board with a real rendered preview of every screen, status pulsing live, and one-tap controls beside each — play, pause, blank, mute, next, hold. Channels group screens into named feeds with a real daily timeline, so dayparting by hour and weekday happens on the schedule rather than in somebody's head, and a live takeover cuts across every screen on a channel instantly.

*Why it matters:* the failure mode of a screen estate is never the design. It is the one board in the back room still looping last month's asset, and a live board makes that visible at a glance.

## Setup before pixel one

| The job | Anthias (formerly Screenly OSE) | ChannelOS |
|---|---|---|
| Get a screen live | Image an SD card, boot a Pi, find its address | Open one URL on the TV — it mints a screen |
| Make a show | Design elsewhere, upload a finished file | Describe it — AI drafts every slide |
| Scheduling | Duration and date range per asset | Channels with hour and weekday dayparting |
| Change what's playing | Per device, one interface at a time | Edit once — every screen derives it live |
| Run the wall | Each Pi is its own island | One live board: play · pause · blank · swap |
| Ongoing cost | Free software, plus hardware and your time | First screen free, then per screen/month |

## A Screenly alternative for people who don't want to run a server

If you are shopping for a Screenly alternative, the useful question is not which product has more features. It is whether you want to own the machine that plays the screen.

**Switch if you do not.** ChannelOS suits the single-site or few-site operator — a café, gym, salon, clinic, dealership, school reception, church hall — where the screens are somebody's second job rather than anybody's department. There is no device to image, no OS to patch, no SD card to replace and no per-device licence, because the TV's own browser is the player: Android TV, Google TV, webOS, Fire TV, a Chromebox, a laptop in kiosk mode. The mechanics are in [no media player required](/blog/no-media-player-required). Switch, too, if the real reason a screen still shows last month's promo is that nobody has time to design the next one — that is a content problem, and no amount of hardware control solves it.

**Do not switch if any of these is a hard requirement.** Screens on a connection that genuinely drops, where local playback is doing real work. A policy that content must stay on hardware you own. A need to read or modify the player's source, or to script deployments as code. If you have already built Edge Apps or wired the Screenly API into something, that work does not port. And if you simply enjoy running the Pis, that is a legitimate reason to stay; nothing here is worth trading a setup you like.

**What you give up by switching**, plainly: offline playback, data locality, open source, and the freedom to write your own player. What you get in exchange: nothing to image or maintain, AI-drafted shows, a schedule every screen follows in real time, and a first screen that is free forever. After that it is per screen per month, on the [pricing page](/pricing). If your objection to Anthias was specifically the self-hosted CMS rather than the Pi, the [Xibo comparison](/blog/channelos-vs-xibo) covers that shape of trade in more detail.

Nothing migrates automatically, and we would rather say so. Anthias assets are finished files, not editable designs, so there is nothing to import. In practice people point the AI at whatever the artwork was made from, rebuild one screen in an afternoon, and leave the Pis running the rest until they are convinced.

## So which should you choose?

Choose **Anthias** if you want to own the hardware and the code, pay nothing for software, and keep playing through an outage — and you are happy to look after a small computer per screen.

Choose **Screenly** if you want that architecture with a fleet console and a developer platform on top, and you would rather pay than maintain.

Choose **ChannelOS** if you want screens live fast, drafted by AI, and run from your phone — with no device behind it and no setup before your first show. Your first screen is free. The test: run one board for a week and see whether you ever wished you could SSH into it. If you did, Anthias is free too and it is the honest answer for you.

## Frequently asked questions

### What is Screenly OSE?

Screenly OSE was the free, open-source edition of Screenly's digital-signage player, built to run on a Raspberry Pi behind each TV. You installed it on the Pi, opened a small web interface served by that device, and uploaded images, videos or web-page URLs as assets to loop. In 2022 the project was renamed Anthias, and it remains open source and free to self-host.

### Is Anthias the same as Screenly OSE?

Yes. Anthias is Screenly OSE under a new name — the project was renamed in 2022 to separate the free, self-hosted, open-source edition from Screenly's commercial hosted product. The code, the Raspberry Pi target and the asset-and-duration content model carried over. Screenly the company remains involved, but Screenly commercial and Anthias are now two different things.

### Does ChannelOS need a Raspberry Pi like Anthias digital signage?

No. ChannelOS runs as a web page in the TV's own browser — Android TV, Google TV, webOS, Fire TV, a Chromebox or a laptop in kiosk mode. There is no Pi to image, no SD card to replace, no operating system to patch and no per-device software to install. You open one URL on the TV and scan the pairing code from your phone.

### What is the best Screenly alternative?

It depends on why you are leaving. If you want the same job done without owning hardware, ChannelOS is the closest fit: it runs in the TV's own browser with no player device and no per-device licence, AI drafts a complete multi-slide show from one sentence, and every screen derives what it plays from a live schedule. If you need offline playback, full data ownership, or the freedom to write your own player code, stay with Anthias or Screenly — a browser-based screen cannot give you those. ChannelOS's first screen is free, so testing the fit costs nothing.

### Who should still use Anthias?

Anyone who is comfortable maintaining Linux devices and wants to own the whole stack. Anthias costs nothing in software, keeps your content on hardware you control, plays from local storage when the network drops, and is open source, so you can read and change it. If those matter more than the time it takes to look after a Pi per screen, Anthias is genuinely the right answer and you should not switch.

### How hard is it to switch from Anthias to ChannelOS?

There is no importer, and Anthias assets are finished files rather than editable designs, so nothing transfers automatically. In practice that matters less than it sounds: you point ChannelOS's AI at the same source material the artwork came from — a PDF, an image, a price list or a webpage URL — and it drafts an editable multi-slide show in a minute. Pairing each TV takes about two minutes and needs no app, so you can leave the Pis running while you move one screen across and decide.