Developer mode.

ardaplayer -dev myapp/ runs your folder in a window with the same window.Arda a device has. By default it is local: nothing is dialled, nothing is registered, and your computer's hardware is never touched. arda.dev.json beside app/ says how it should run.

Working — describes ArdaPlayer v1.2.3

Local, or a desk device

	Local (the default)	`"device": true` (or `-device`)
Network	none needed; no server contacted	enrols this folder as a device; you claim it in the portal with the code it shows
`Arda.device().phase`	`local`	`unregistered` → `ready`
Datasets	a store for every manifest dataset; seeds; your pushes read back at once	synced from ArdaForm; pushes travel; the manifest is sent so missing datasets are created
`Arda.config`	manifest defaults + `settings` from the file	the portal's values for this device
Webhooks	the file's `webhooks` list, called from your machine	the same list if given, else the project's webhooks

Each folder is its own device. Its identity lives in the folder's state/: two folders are two devices with separate data. Keep state/, data/ and storage/ out of git.
Records you pushed while local travel up the moment the device is turned on.
Developer data is disposable: delete data/ to start the local stores again (and reload the seeds).
The manifest is watched: a save takes effect in about two seconds, without a restart.

arda.dev.json

arda.dev.json every key

{
  "window": "1280x800",
  "scale": "75%",
  "bg": "#000000",
  "console": true,
  "watch": true,
  "device": false,
  "can": { "touch": true, "keyboard": false, "mouse": false },
  "screens": [
    { "name": "main", "primary": true },
    { "name": "customer", "size": "800x480", "console": true },
    { "name": "cctv", "size": "1920x1080", "kind": "video" }
  ],
  "partition": "11",
  "settings": { "shop_name": "Test shop", "show_vat": false },
  "devices": { "wifi": { "enabled": true, "networks": [ { "ssid": "shop", "key": "pretend-password" } ] } },
  "webhooks": [ { "slug": "loyalty", "url": "http://localhost:3000/hook", "method": "post", "key": "dev-only-key" } ]
}

Key	Flag	Meaning
`window`	`-window`	the app's screen size
`scale`	`-scale`	draw the window smaller (`"0.75"` or `"75%"`); the app keeps its resolution. Every named screen follows it.
`bg`	`-bg`	the colour before the app has painted
`console`	`-console`	open the inspector at start. Off by default; right-click → Inspect works on every window anyway.
`watch`	`-watch`	reload the page whenever a file in `app/` changes. Off by default.
`device`	`-device`	make this folder a real device (above)
`can`		what the app is told this machine has: `screen`, `keyboard`, `mouse`, `touch`, `audioOut`, `audioIn`. `false` means "pretend there is none"; leaving a key out reports the truth. It does not create input: no touch events come from a mouse, so write against pointer events. The portal is still told the truth.
`screens`		the screens to pretend to have: `name`, `size`, `primary`, `console`, `kind`. The first (or the one marked `primary`) is the app's; the others open as windows, as `Arda.screen[name]`. `"kind": "video"` stands in for a device's second monitor, where `Arda.camera.show` draws a camera.
`plane`, `planeCA`	`-plane`, `-plane-ca`	for ArdaForm's own testing of a new server; they work only with a player built for it. Leave them out.
`partition`		the data partition this run stands in: partitioned datasets are filtered on the record's top-level partition field
`settings`		your values for the app's settings, over the manifest's defaults
`devices`		pretend peripherals; today a Wi-Fi radio whose networks `Arda.wifi` lists and whose keys it checks. Given, it replaces the real radio.
`webhooks`		`{slug, url, method, key}` entries the player calls itself (Webhooks)

The command line wins over the file.
An unknown key is refused, with its name, rather than ignored.
It is for developing and never ships. ArdaForm does not pack it; outside -dev the player refuses to start if it finds one, and a container that holds one does not open. Committing it is harmless — but it is a file on a desk, so use pretend passwords and throwaway keys in it.
ardaplayer -h (section Developer settings) is the authority for the current list.

What is simulated

Arda.system.shutdown() / reboot(): a five-second notice, {ok: true, simulated: true, message}.
Brightness, contrast, scale and volume writes: {ok: true, simulated: true}; reads are real where your machine allows.
The power button stays your computer's. Bluetooth addresses and the firewall are never touched.
Wi-Fi: the pretend radio when devices.wifi is given, otherwise the real one (a desktop without Wi-Fi answers "this device has no wireless").

Which build

The Linux desktop build opens the app in its own WebKit window: the engine the devices draw with. Use it to judge layout and camera playback.
The Windows and macOS builds open the app in an installed Chrome-family browser or the system browser. The API is the same; drawing differs from a device.
Encrypted apps (app.arda) are refused in developer mode: on a desk you always run source.

Removing a desk device: -unbind

shell

$ ardaplayer -unbind myapp/        # developer mode: no password asked

Removes the folder's device: its identity and synced data, after ArdaForm has forgotten it (safe to run again if interrupted). The folder's app/ is left alone. On a real device the same flag asks for the device password shown in the portal. The portal shows a removed device as a fading "ghost" for a few days.

Checked: the key list matches ardaplayer -h and cmd/ardaplayer/devconfig.go; the file above is accepted by the player (a local run with it started without an "unknown key" refusal). Local-run behaviour (seeds, echo, config, webhooks, the local phase) was observed. The desk-device path and -unbind were not run for this page.

PreviousThe settings page NextPackaging and updates