FrogNet · installation

Standing up
a node.

From a bare Linux box to a fully-configured lillypad — one phase at a time. Nothing joins a network yet; that comes after.

seven phases · one machine ·

Current implementation: the shared-RAM contract and engineering record

Use matching packages and inspect their build.

TargetCurrent package in the source treePrerequisite
Linux x86-64 nodeopt/fdf/dist/fdf-install-x86_64.runExisting FrogNet installation; root, python3, wg, systemctl and tar.
Linux ARM64 nodeopt/fdf/dist/fdf-install-aarch64.runSame existing installation requirement; matching architecture.
RAM manager + hubopt/fdf/dist/fdf-droplet.tgzOperator’s site configuration, reachable service ports and systemd units.
Windows x64opt/fdf/windows/bridge/Administrator terminal; amd64 wintun.dll from its authors.
Androidopt/fdf/src/frognet-android/Android build environment; membership app includes Communicator.

The source archive reviewed here is r19-a15. Read the BUILD file and startup logs on the machine you are using. A filename alone does not prove the deployed version. The packages are in the repository tree; this website archive does not contain those large release binaries.

Linux node update.

Have the region operator prepare the RAM manager and hub first. Copy the matching .run file to the node, supply the operator’s site key privately, and run the architecture-specific installer. The installer checks the existing FrogNet path and configures region membership. It prints the installed build and a startup report.

sudo bash /tmp/fdf-install-x86_64.run <SITE_KEY>
# ARM64 node instead:
sudo bash /tmp/fdf-install-aarch64.run <SITE_KEY>

These are the existing package invocation forms, not a clean-machine installation promise. The reviewed cleanup plan identifies broker-generated key and installer dependencies that need correction before fresh region installs can be claimed.

Windows bridge.

Copy the bridge folder to the PC. Obtain bin\amd64\wintun.dll from the authors’ Wintun package and put it beside the launcher. Edit etc\ponds.txt, one area=host:port per pond. Open an Administrator terminal in the bridge folder.

fdf-bridge.cmd

# In another terminal:
fdf-bridge.cmd ask status
fdf-bridge.cmd ask resolve w:<GUID>:<PORT>
fdf-bridge.cmd ask comms
fdf-bridge.cmd forward <POND>

The first run creates the PC’s identity, key and facts. It places the PC on the mesh or builds the off-mesh hub path. Ctrl-C ends membership and removes the adapter routes and tunnels. Stop any older hand-configured client/tunnel using the same key before starting this bridge.

Android member and Communicator.

Build the current membership app from opt/fdf/src/frognet-android. The reviewed project uses compileSdk 34 and minSdk 29. Configure the ponds, start membership and grant the platform’s VPN consent for its TUN. The Communicator button opens the app’s own Communicator screen using the pond’s resolved RAM and media identities.

The old standalone Android Communicator is superseded. Android r5 combines the current pond-based launch with full-screen call controls, a movable camera inset, fill/fit, stats and camera selection. Keep sources and embedded fdf-tun binaries together.

Observe the network you actually joined.

/opt/fdf/bin/fdf-monitor --once
/opt/fdf/bin/fdf-ls --watch
cat /opt/fdf/BUILD

Inspect participant facts, planned routes, hub handshake state and the device’s hosts-file name. A successful session is one check; a working packet path is another. The operator controls port exposure and access policy. Read the deployment boundaries.

STEP 01
Base configuration

Start with the machine

FrogNet runs on hardware you already own.

  • Any spare computer
  • A Raspberry Pi, a mini-PC, an old laptop
  • One box is already a complete network

It asks for three things — Linux, a little memory, and a way to talk.

STEP 02
Base configuration · the OS

It's just Linux

A Debian-family Linux base — nothing exotic.

Python, PHP, bash — no unusual dependencies. It runs almost anywhere.

Debian / Linux
the base OS
Any CPU
x86 or ARM, Pi-class up
STEP 03
Base configuration · memory

A couple of gigs of memory

Two gigabytes is the floor.

  • 2 GB of RAM, minimum
  • More headroom for media and on-node AI

Enough to run the node, its apps, and the adaptive media loop at once.

STEP 04
Base configuration · interfaces

At least one way to talk

One interface is required. More is better.

  • A single interface is the minimum
  • Multiple interfaces are recommended
  • Each one is another bearer the node can use
One interface
the minimum
Two or more
recommended
STEP 05
Phase 1

Qualify the machine

The installer reads the box before it touches it.

  • Debian / Linux base
  • At least 2 GB of memory
  • At least one network interface

Pass, and install proceeds. Fall short, and it tells you exactly why.

STEP 06
Phase 2

Update, then install

This phase needs you online.

  • A full system update runs first
  • Then one script lays down the FrogNet world
  • The only phase that requires connectivity

Once it's done, the node stands on its own.

STEP 07
Phase 3

Give it an identity

Every node gets a permanent name and a fixed address.

  • A permanent GUID in /etc/fnid
  • A human name you choose
  • A fixed .1 address — e.g. HomeBase 10.80.80.1

Set once, and it is how the node is known from then on.

STEP 08
Phase 4

Choose the bearers

Tell the node which links it may use. Any mix is valid.

Wired, WiFi, or radio — the node treats them all the same. The link is just a pipe.

eth0 / eth1
wired links
wlan0 · WiFi
upstream, or to another FrogNet
900 MHz radio
long-range RF
STEP 09
Phase 5

Set the uplink & AP rule

How the node offers WiFi depends on what's on eth0.

  • Router on eth0 → it must run in AP mode (added for power)
  • Nothing on eth0 → wlan0 takes the hostapd config
  • dnsmasq serves DHCP and the .1 identity range

External WiFi on a Pi: the BrosTrens WiFi 6 antenna is the verified option.

Router on eth0
must be AP mode
No eth0
wlan0 becomes the AP
STEP 10
Phase 6

Bring it up at boot

netstart configures the node's networking on every power-on.

  • hostapd projects the SSID
  • dnsmasq hands out the .1 range
  • Discovery comes up armed, waiting

The node makes itself ready — before anything else is even in range.

STEP 11
Phase 7 · the end state

Configured —
and waiting.

A complete lillypad: powered, self-consistent, and alone.

  • Identity set
  • Interfaces up
  • AP projecting its SSID
  • Discovery ready

No peers, no broker, no mesh — yet. The moment another node appears, they'll find each other on their own.

You now have one running

The cheapest contribution is a topology that breaks it

You do not need to read the engine or write a line of it. The simulator takes a topology and runs the real discovery, routing and election code against it. Build one that produces a wrong answer and you have found something nobody else did.

  • No licence, no engine access, no Python
  • The simulator runs the real code, not a reimplementation
  • A topology that fails today and passes on a fix is an oracle

Better gets demonstrated, not argued — and the gate does not care who either of us is.

Run the simulator →  ·  The autonomics seam →