AF-01 Running on devices in the field

Build dedicated
devices with
JavaScript.

ArdaForm turns a Raspberry Pi, a small PC or an Android tablet into a device you can install anywhere and look after from your browser. Write the screen as an ordinary web page — HTML, CSS and JavaScript — push it to GitHub, and every device picks it up by itself, at a moment your app agrees to. Then see its screen, change its settings and fix it from the portal, wherever it is.

NEW Now on Android — tablets, displays, TV boxes
Plain HTML & JavaScript Deploy with git push Works offline Managed from the portal
Runtime architecture 04 layers
04
Your applicationHTML · CSS · JavaScript · app/manifest.json
</>
03
ArdaPlayerOne program · your page full screen, no desktop
02
Device APIsPrinters · serial · readers · screens · audio · Wi-Fi
ALLOW-LISTED
01
Dedicated deviceRaspberry Pi · x86-64 · Android tablet · a card, a stick or an app
▱
● Offline ready No open ports ●
Print receiptsRead barcodesTalk to serial portsDim the screenWork offlineJoin Wi-FiAdopt over BluetoothSync datasetsShow IP camerasCall webhooks
Sealed packagesEncrypted storesRemote screenRemote consoleRoot shell on demandStaged updatesSelf-updating runtimeOn-device identity

The ArdaForm idea

A touchscreen in a shop shouldn't need a 200 MB runtime, a folder of hardware shell scripts and a week of Linux configuration before it does anything useful.

Start here

Basic HTML and
JavaScript is enough.

If you can write basic HTML and JavaScript, you can build an app and run it on one device — or hundreds. The app is an ordinary web page. Deploying it is a push to GitHub. Setting up a device is writing a card and typing a code. You don't need to know Linux, networking or how a device talks to the portal: that part is ArdaForm's job.

1 · Write a web page

An index.html, some CSS, some JavaScript — the same things you would write for a website. Any editor, any framework, or none.

app/index.htmlWorking

2 · Try it on your computer

One program opens your page in a window that behaves like the device — touchscreen, settings and data included. No hardware needed yet.

ardaplayer -devWorking

3 · Push it to GitHub

Connect the repository to your project in the portal once. From then on, every push reaches your devices by itself.

git pushWorking

4 · Switch on a device

Write the ready-made image to a Raspberry Pi card or a USB stick, switch on, and type the code it shows into the portal. The tenth device is the same as the first.

Add deviceWorking
●
The technical part is done for you The encryption, the signed updates, the connection back to the portal, the firewall on every device — all of it is on from the first boot, with nothing for you to configure. It is described further down this page and in the docs for anyone who wants to know how it works; you never have to. The quickstart starts from an empty folder.
01 / Try it

Touch the portal.
Watch the device.

This is the portal's device screen beside a device — the same controls an operator has. Move the brightness, take a screenshot, reboot it, or push a change from git and watch it arrive. On a real device it works like this, and takes about as long.

portal.ardaform.net/projects/12/devices/40
ArdaForm Northgate Fitness / Check-in / Devices / Reception sam
DevicePeripheralsSetupAlerts & logDevice viewSSHBluetooth
Raspberry Pi 4 Model B connected
NameReception · arda-9k2f Local IP192.168.1.42 · wlan0 Playerv1.2.3 · Raspberry Pi OS 13 Branchmain · 3f9c1e2
80%
40%
Device view console
Northgate Fitnessmember check-in
Northgate Fitness · Reception online · 07:41
Scan your member codeHold your member QR to the scanner, or type your number.
Visits today 212
Spin · 08:00 4 places
Day pass £8.00
v1.4.1
Check inType numberDay passHelp
Drag brightness Press Screenshot Reboot it a change
02 / The platform

Everything between your
code and the device.

ArdaForm is not a UI framework. It is everything underneath — getting the app onto the device, talking to printers and scanners, keeping data in step, looking after a fleet — so you can spend your time on the screen people actually touch.

Sealed packages

Push a commit and ArdaForm packs your app into one encrypted file that only your devices can open (a sealed .arda, AES-256-GCM). It is opened in memory, never unpacked to disk, so no readable source sits on hardware you don't control.

app.ardaWorking

Device APIs

Print a receipt, read a barcode, show a camera, dim the screen, join Wi-Fi, call your own server — all from ordinary JavaScript. Receipt and label printers, USB-serial, barcode and NFC readers, IP cameras, screens, audio, an on-screen keyboard and webhooks, through one object.

Arda.printers.print()Working

Offline-first data

Keeps working when the internet doesn't. The data your app reads is kept on the device, each device getting only its own share. Anything it saves — a sale, a check-in — waits safely on the disk, even through a power cut, and is sent when the line is back.

Arda.db.push()Working

See the device

From the portal: what its screen shows right now, the app's console, a line of JavaScript run in the page, a full-resolution screenshot, its log, and a terminal on the machine — without visiting, and without opening anything on the shop's network.

Device viewWorking

Git to device

Connect your GitHub repository once. Every push after that reaches your devices by itself: each one checks the update is genuine, gets it ready, and switches over when your app agrees — as soon as it lands, overnight, or only when asked.

git pushWorking

Whole-device images

Ready-made images for a Raspberry Pi card and a PC, and a USB installer you click through on the screen: choose the disk, a name, the Wi-Fi and an install code. No Linux setup. The device registers itself and keeps its own software up to date from then on.

ardaplayer-rpi-arm64.img.xzWorking
03 / The bridge

JavaScript you
already know.

Talking to hardware is usually where a web developer has to stop. Here it is a function call. ArdaPlayer puts one object, window.Arda, in your page before your first line runs — nothing to install, nothing to compile, no Python scripts on the side — and it is the same object on your desk, on the kiosk, and on a box with no screen at all.

  1. 01
    One objectEverything hangs off Arda — device, config, datasets, files, keyboard, screens, audio, cameras, printers, serial, Wi-Fi, updates, webhooks.
  2. 02
    Promises, not callbacksEvery call returns a promise and rejects with a sentence you can show — "the password for shop was not accepted".
  3. 03
    Same on the deskardaplayer -dev myapp/ runs it in a window with a pretend touchscreen and a pretend radio. Power calls are simulated; nothing touches your laptop.
1// The settings the operator typed in the portal
2const name = Arda.config.kiosk_name ?? 'Reception'
3
4// A synced dataset — asking is subscribing
5let members = await Arda.db.dataset('members')
6Arda.on('sync', async (ds) => {
7  if (ds === 'members') members = await Arda.db.dataset(ds)
8})
9
10// A badge scanner is a keyboard wedge; the player knows which one
11Arda.on('barcode', async (s) => {
12  const m = members[s.text]
13  if (!m) return refuse()
14  // Durable: queued on disk, delivered when the line is back
15  await Arda.db.push('visits', { member: m.id, kiosk: name, at: Date.now() })
16  welcome(m)
17})
04 / The pipeline

One push.
A fleet in the field.

You push; the devices do the rest. Each device keeps its own connection out to ArdaForm, so there is nothing to set up on the customer's network — no ports to open, no VPN — and every update, lock or wipe is signed for that one device and checked by it before anything happens.

A / Push
</>

A commit lands

Your repository, your editor, your way of working. Push as you always do.

B / Pack
.ARDA●

Sealed, never run

ArdaForm packs your app folder into one encrypted file. Nothing from your repository is ever run.

C / Instruct

Sent to each device

A signed instruction per device, carrying the file's fingerprint (sha256) and its key. A device that is switched off gets it when it comes back.

D / Apply

The app picks the moment

Downloaded, checked, made ready — and swapped in when your app says it's a good moment. Never mid-sale.

Checked on the device Two devices, 29 ms apart Devices reporting Measured on the fleet, 2026
05 / Provisioning

Four steps from
bare metal.

The images exist so that turning hardware into a device is a job you can hand to somebody who has never opened a terminal — and a headless box on a cable can be adopted without touching it.

  1. 01 Flash

    Write a card or a stick

    Download the Raspberry Pi image, the PC image or the USB installer from the portal. The installer is ArdaForm running an install app: choose the disk, name the machine, join Wi-Fi, type an install code — on a touchscreen or a keyboard.

    Working
  2. 02 Adopt

    Register the device

    It shows a short code on its screen; type it into the portal and the device is yours. No screen? A device on your network appears in the project's Adopt tab, one with no network is found over Bluetooth and handed its Wi-Fi from the browser, and an install code registers it before anybody logs in.

    Working
  3. 03 Run

    Fetch, sync, start

    The device downloads your app and its data, checks them, and starts the app as soon as what it needs to begin with is there — pictures keep arriving behind it.

    Working
  4. 04 Keep

    It looks after itself

    When a new ArdaPlayer is released, devices update themselves: each one checks the download, proves it starts, switches over at the next restart — and goes back to the previous version by itself if the new one cannot stay up.

    Working
●
The whole path, written down From a folder to a device walks every step with the portal screens beside it — the files, the commands, the tabs — in a form a person or an AI assistant can follow end to end. The developer manual then covers everything an app can do, area by area, with examples.
06 / Android

Already have a tablet?
Install the app.

ArdaPlayer is also an Android app: the same player, the same app, the same portal — on the tablets, the displays with Android inside and the TV boxes a business already owns. No card to write and no image to flash: open a link on the tablet, install, and type the code it shows into the portal.

An ordinary app

On a tablet beside the till it runs your app like any device: its data kept through a lost connection, Wi-Fi receipt printers found on the network, the battery and its charge in the portal, the screen held in landscape or portrait. Staff can still switch to other apps.

Android 7+Working

A locked kiosk

Make the player the box's device owner once — one command on a freshly reset tablet — and kiosk mode becomes a switch in the portal: no status bar, no Home, no Recents, the player starting with the box. Switch it off from the portal when the box is needed for something else.

Kiosk modeWorking

Signage on the screen you have

Many commercial displays and most TV boxes run Android. Play video and pictures from the project's files, offline, with no Raspberry Pi behind the screen and no second power supply. One app covers 64-bit and 32-bit ARM and x86-64 boxes.

<video>Working
i
What an app cannot do Android gives an app no power-off, no firewall and no root shell, so Shut down closes the player there, and SSH, the firewall and the device images stay Linux-only. The app comes from this site rather than Google Play, so Android warns before installing it — the manual walks through it.
07 / Built for

Software with
a physical address.

If it has a screen, a plug and a job to do, it's an ArdaForm device. The same runtime, the same portal, a different app.

A tablet in an edge-lit frame on a gym reception desk asking members to scan their code01

Member check-in

A badge or a QR read by a USB scanner, the visit saved even if the line is down, a welcome on the glass. A day pass sold from the same screen.

A rugged wall tablet in a warehouse aisle showing a pick list02

Warehouse pick station

The pick list synced per bay, each scan attributed to the scanner that made it, and the list still there when the Wi-Fi in aisle nine isn't. The bay's camera plays beside it.

A small panel beside a meeting-room door showing the room is free until two o'clock03

Room panels

A Pi behind a seven-inch panel on every door, adopted over the office network without a keyboard, its edge light driven from the booking data.

A floor-standing pay-and-display station with a touchscreen, keypad and ticket slot04

Pay stations

A keypad, a card reader on serial, a receipt printer — and an operator who can see the screen from the office when a driver rings.

An industrial panel PC in a cabinet door showing a production line running with three gauges05

Line panels

A panel PC on the cabinet door, the PLC on the other end of a serial cable, and a night-time update window so the line never sees one.

A large wall screen in a clinic showing the number now being served06

Queue boards

A big screen driven by a Pi the size of a card, updated from the same dataset the counter staff write to, screenshot on request.

08 / Security

Hardware you don't own,
running code you do.

Devices live in shops, factories and reception areas — physically accessible to people you've never met. ArdaForm assumes that from the start.

Signed instructions

Every update, lock and wipe is signed for one specific device (Ed25519), and the device checks it before it acts. One device's wipe cannot be replayed at another. A reboot is asked live, over the device's own connection, and never queued.

Sealed at rest

Your app and its data are encrypted with a key that belongs to that device and the board it sits in. Copy the card into another machine and it opens nothing.

No inbound ports

The device calls out; nothing can call in. Its firewall answers nothing it did not ask for, and even SSH stays shut until you open it from the portal, for a set time.

Allow-listed access

Remote support reaches only what the device itself offers — its screen, its shell — by name, never an address of our choosing. ArdaForm's side cannot turn a device into a way into its owner's network.

i
No absolutes A device you don't physically control is never perfectly secure, and we won't pretend otherwise. Sealing is anti-cloning, not anti-theft; the answer to a stolen device is the wipe it takes the moment it reconnects — read the security model.
09 / Questions

Asked often.

The short answers. The help pages and the developer manual have the long ones.

What is ArdaForm?

ArdaForm is a platform for building, deploying and remotely managing dedicated applications on Linux and Android devices. You write the application in HTML, CSS and JavaScript and push it to a git repository; ArdaForm packs it, delivers it to the hardware running the ArdaPlayer runtime, and gives you a portal to update, watch and support every device in the field.

What hardware does ArdaForm run on?

Raspberry Pi 3 and 4 boards with HDMI or DSI touchscreens, and x86-64 machines such as mini PCs, panel PCs and point-of-sale terminals. Ready-made images and a USB installer are downloadable from the portal; an existing Debian machine can be converted. Android tablets, displays with Android inside and TV boxes (Android 7 or newer) run the ArdaPlayer app instead.

Does ArdaForm run on Android?

Yes. ArdaPlayer is also an Android app for tablets, displays and TV boxes, installed from ardaform.net rather than Google Play. It runs the same app with the same data and the same portal; set up once as the box's device owner, it can be locked to the app from the portal.

Is ArdaForm available yet?

Yes on real hardware: the runtime, the device images, the Android app, git deployment, data sync, remote support and self-updating players run on devices in production today. Anyone can create a portal account; the free plan needs no card.

Get started

Build different.
Deploy anywhere.

ArdaForm is for anyone putting a screen to work — web developers, integrators and software vendors alike. The runtime and the images are real, and the portal is open — create an account; the free plan needs no card.