One phone is nice. Two phones, or a phone and a board, is where FIELD gets interesting.
This guide picks up after Your First FIELD. It assumes you already know the four words — Actor, Role, Cue, Mechanism — and that you have built at least one small thing.
You will meet three scenarios, then learn how to add even more devices, then build one real project that uses everything.
No laptop needed once paired. Good for two people, face to face.
No phone, no router. Good for an installation in a corner with no Wi‑Fi.
The normal FIELD way. Everything lives on one canvas, at once.
However many devices you connect, each one is still just an Actor with senses and reactions. A Cue does not care if it is joining two phones, two boards, or one of each. Learn the pattern once.
You and a friend each hold a phone. Tilt yours, and something changes on theirs — with no laptop in the room after you set it up.
FIELD calls this Phone Export. The two phones send data straight to each other, phone to phone, once they've paired.
Both phones need the FIELD server (your computer) only for a few seconds, to trade the room code. After that, sensor data flows phone‑to‑phone directly. You can close the laptop.
The connection type behind Phone Export is called WebRTC. The brief handshake where the phones trade the room code through your computer is called signaling. Once that's done, the link is direct, phone to phone — this pattern is called P2P (peer‑to‑peer). None of these names matter for using FIELD; they're just what the underlying tech is called if you go looking.
Two ESP32 boards send sensor data to each other over their own radio — no Wi‑Fi network required at all.
FIELD calls this connection type ESP‑NOW (a feature built into the ESP32 chip itself). Good for outdoor pieces, or any spot where you cannot rely on a router.
This trick needs the ESP32 chip specifically — not a classic Arduino, not an ESP8266. Picking it in FIELD switches your board choice to ESP32 automatically.
With several ESP‑NOW pairs running nearby, an empty Peer MAC field means every board also listens to every other pair's traffic. Lock each pair together like this:
AA:BB:CC:DD:EE:FF.Now each board only accepts messages from the specific address you gave it, ignoring any other pair nearby.
Turn a knob on Board 1, and whatever Board 2's output role controls — a light, a motor, a sound — reacts immediately. It works exactly the same as everything else in FIELD, just carried over radio instead of a wire.
This is the way FIELD works most of the time. The laptop stays open and acts as the hub. Nothing needs pairing codes or MAC addresses — you just add both as Actors.
This mode is the most flexible: any Actor's sense can drive any other Actor's reaction, you can add a third or fourth Actor any time, and Scenes can turn whole groups of Cues on and off. Reach for Phone Export or ESP‑NOW only once you know you want to leave the laptop behind.
The model never gets bigger than four words. Only the number of Actors and Roles grows.
A single Actor can carry several of the same sense — say, twelve TOUCH roles for twelve buttons on one board. FIELD numbers them for you (first one plain, then "_1", "_2", and so on), and each one is still a normal Role you can draw a Cue from.
Each of these shows up in the same Connect menu you used for the phone and the board. Once connected, it behaves exactly like any other Role, ready for a Cue.
If you have a sensor chip FIELD does not know yet, a plugin teaches it — a single small file, no install step. A plugin never invents a new kind of sense; it only teaches an existing one (TOUCH, LIGHT, SOUND…) how to talk to one more chip. See Add a Custom Sensor for a full walkthrough.
Display Studio lets you design a picture for a small hardware screen — icons, text, bars — and bind pieces of it to your senses or Cues, the same way you would bind a Cue to an LED.
Take the phone‑and‑board project from the last chapter. Add one more device — a second phone, or an OSC value from a laptop app — and draw one new Cue into it. Notice that nothing about the first two Actors had to change.
One phone, one board, and a screen — three Actors working together, with a Scene that changes the mood.
Here is what you are building: tilt your phone and a cloud drifts across a sketch. The board's real light sensor sets how bright the sky looks. Shake your phone, and a storm begins — the board's LED starts flashing along with it.
TILT and SHAKE. Your phone, connected the normal way.
LIGHT input from a light sensor on pin A0. GLOW output to an LED on pin 5.
MOVE and GLOW outputs, drawn by a p5 sketch.
sketch.js
function setup() {
createCanvas(500, 300);
}
function draw() {
// Screen.GLOW: real daylight sets how bright the sky looks.
let daylight = field.get('GLOW');
background(200 * daylight, 210 * daylight, 235);
// Screen.MOVE: your tilt slides the cloud left to right.
let tilt = field.get('MOVE');
let x = tilt * 500;
fill(255);
ellipse(x, 90, 120, 50); // the cloud
// The active Scene's name, so the sketch can react to it too.
if (field.scene() === 'Storm') {
fill(60);
text('STORM', 20, 280);
}
}Two different device types (phone, board) drive the same sketch, through the same simple rules. A Scene turns a whole group of Cues on and off at once. And the sketch never asks where a number came from — it just asks for field.get(...).
Swap Board.LIGHT for an MQTT subscription to a public weather feed. Cue 2 does not need to change — Screen.GLOW still just receives a number, now from across the internet instead of across the room.
Phone to phone, board to board, phone to board — and a project that used two device types and a Scene at once.