Plan it. Simulate it. Operate it.
Predictive WiFi & camera design · a Packet-Tracer-class network simulator · live device operation — one app, no backend.
▶ Try it in your browser — nothing to install; click Load sample project.

Drag an access point: its coverage re-clips against the walls as it moves.
What makes it different
- One model, three uses. The drawing is the simulation is the device config. Nothing is re-entered.
- It never touches a device on its own. Reading a config is one fixed read-only command; pushing one is a
rosconfdry run that you turn into an apply. - No backend, no account. A project is a single JSON file. Credentials can be encrypted in it with a passphrase.
- Untrusted by default. A project file from someone else is treated as hostile input everywhere — in the page, in the SSH launcher, in the file dialogs.
- What is Plexus?
- The three modes
- Install
- Tutorial 1 — Design a WiFi plan
- Tutorial 2 — Simulate the network
- Tutorial 3 — Operate: connect to a real device
- Feature reference
- Keyboard shortcuts
- How it works (architecture)
- The coverage math
- Build & desktop installers
- Tests
- Project layout
- Project file format
- Roadmap · Contributing · Security · License
Plexus is a network site planner, simulator and operator in a single app that
runs in any browser or as a native desktop build. You design a network on a floor
plan, turn that same design into a working simulated network you can ping
and configure over a Cisco/MikroTik CLI, and then connect to the real gear over
SSH — all from the same canvas. No backend, no accounts; a project is one JSON file
you can email.
Live demo (deployed from
main) · Download the latest release for macOS.dmg, Windows.exe, Linux.AppImage/.deb, or the portable browser zip · Changelog
Plexus has one canvas and three workspace modes. The top-bar switcher changes which tools are available, so each mode stays focused.
flowchart LR
A["Design<br/>place devices · draw walls<br/>RF coverage & heatmaps"]
B["Simulate<br/>ping / traceroute · VLANs<br/>OSPF/RIP · IOS/RouterOS CLI"]
C["Operate<br/>connect to real devices<br/>over SSH (desktop only)"]
A --> B --> C
C -. "same project" .-> A
| Mode | What you do | Key |
|---|---|---|
| Design | Lay out APs, cameras, switches/routers, walls; read wall-aware coverage + heatmaps. | A |
| Simulate | Run packets on your design: VLANs, routing, DHCP/DNS/NAT, a per-device CLI. | M |
| Operate | Open an SSH session to the real device you clicked. Desktop build only, behind a confirmation. | — |
Open the live demo, or grab
the portable zip from Releases,
unzip, and open index.html. Fully offline, runs from file://.
The browser build does everything except the desktop-only features (Operate / SSH, live WiFi survey, UniFi sync) — those need the native app.
Download the installer for your OS from Releases:
| OS | File | First-launch note (unsigned build) |
|---|---|---|
| macOS | .dmg / .zip |
Right-click → Open → Open. If still blocked: xattr -dr com.apple.quarantine "/Applications/Plexus.app" |
| Windows | .exe (NSIS) |
SmartScreen → More info → Run anyway |
| Linux | .AppImage / .deb |
chmod +x *.AppImage then run |
git clone https://github.com/s-markakis/plexus-network-planner
cd plexus-network-planner
npm install
npm run dev # browser dev server → http://localhost:5173
npm run app:dev # OR launch the desktop appRequires Node 18+ (LTS recommended).
Goal: a floor plan with wall-aware coverage and a signal heatmap.
- Start a project. Click Load sample project to start populated, New from template… for a villa / hotel / restaurant with its VLAN plan and policies already written, or Upload Map and pick a floor plan (PNG / JPG / SVG / PDF).
- Set the scale. Click Calibrate, draw a line over a dimension you know (a doorway, a wall), and type its real length — or type Scale directly as metres per 100 px. High-resolution plans are fine: the scale can be well below 1 m / 100 px, and every device keeps its range in metres when the scale changes. With a scale set, the heatmap uses physical, FSPL-based path loss.
- Draw walls. Press L and drag (hold Shift to snap to 45°). Pick a material — drywall, glass, brick, concrete — each attenuates differently. Or import walls from an SVG/DXF, or auto-detect them from the bitmap.
- Place access points. Press A and click (the drawing tools are the palette on the left edge of the map). Each AP renders its actual wall-clipped coverage polygon, not a circle. A router with a built-in radio (UniFi Dream Router, MikroTik hAP, …) placed with the switch tool gets coverage too — see Routers with WiFi.
- Turn on the heatmap. Open Layers → Heatmap, then cycle the metric pill through RSSI → SNR → SINR → MCS → Throughput. With several floors, Settings → Include other floors in heatmap adds the APs above and below, through the slabs.
- Optimize. Use Auto-place (drop APs to hit 92% coverage), Auto-channel (graph-colouring), and Auto-power.
- Deliver. Export a branded PDF, BoM/cable-schedule CSV, or a one-zip Handover pack.
![]() |
![]() |
| Coverage polygons — wall-clipped, with camera FoV cones | Heatmap — RSSI (ITU-R P.1238 indoor model) |
More screenshots — throughput heatmap, cable runs, templates, settings, light theme
![]() |
![]() |
| Estimated-throughput heatmap | Cable runs to switches, with lengths |
![]() |
![]() |
| Site templates: VLAN plan, policies and naming per kind of site | Project settings |
Light theme. Every image here comes from the bundled sample
(files/src/sampleProject.js) and is regenerated with npm run docs:media
(scripts/media/readme-media.spec.js; the GIF needs ffmpeg).
Goal: make the design forward real packets, route between VLANs, and take CLI config.
Switch to Simulate (press M). The packet-sim panel opens.
Ping across the topology
- Pick a source and destination device.
- Click Ping — an animated PDU walks the map hop by hop; the step inspector shows each decision (ARP → L2 forward → L3 route → deliver).
sequenceDiagram
autonumber
participant PC1 as PC-1 (VLAN 10)
participant R as L3 Switch
participant PC2 as PC-2 (VLAN 20)
PC1->>R: ARP who-has gateway?
R-->>PC1: ARP reply (SVI MAC)
PC1->>R: ICMP echo → 10.0.20.x
Note over R: route lookup<br/>longest-prefix match
R->>PC2: ICMP echo (routed)
PC2-->>PC1: ICMP echo-reply
Configure a device from the CLI
Select a switch/router → CLI Console. Type real Cisco IOS or MikroTik RouterOS; the simulator forwards accordingly.
# Cisco IOS — inter-VLAN routing on an SVI
interface vlan 20
ip address 10.0.20.1 255.255.255.0
no shutdown
!
router ospf 1
network 10.0.0.0 0.0.255.255 area 0
# MikroTik RouterOS — the equivalent
/ip address add address=10.0.20.1/24 interface=vlan20
/routing ospf instance add name=default
/routing ospf network add network=10.0.0.0/16 area=backbone
What the simulator models: L2 switching + VLANs + MAC learning, ARP,
L3 routing (connected/static + OSPF and RIP), DHCP, name-based
DNS (ping AP-01 resolves), NAT/PAT, ACL/firewall, an internet
cloud, and link-down fault injection. Drop a wireless client (K)
and it associates to the best AP by real signal, then gets a DHCP lease.
Testing a design in the sim panel
-
Ping / Traceroute between any two endpoints — and to gateways, switch management addresses and the Internet (they appear as extra "To" targets).
-
Probe port — "can the camera open
tcp/554on the NVR?" → open, closed (nothing listening) or filtered (a firewall rule dropped it). -
Faults — power off a switch or cut an uplink, then re-run the test. Routes over the dead link are withdrawn and OSPF/RIP reconverge on what is left.
-
VLAN matrix — every VLAN against every other: ✓ allowed, ⛔ blocked by a rule, ✗ no route. The same table is added to the HTML/PDF report.
-
Blast radius — pick a device and ask "if this is compromised, what can it reach?": every reachable address and open service, with the findings a segmentation review would raise (management exposed to a camera VLAN, no filtering between segments, outbound Internet).
-
Scenario queue — queue several pings/probes and run them back to back on one warm network (later tests see the ARP/MAC tables and connections of earlier ones).
-
Playback — step or auto-play the event list at 0.5×–4×, filter it by protocol family (ARP, switching, routing, ICMP/L4, firewall/NAT), and inspect each step's PDU by OSI layer.
Policies — intent as tests (Simulate → ✓ Policies). State what must and must not be reachable ("Guest must NOT reach Management", "Staff must reach the NVR on tcp/554") and Plexus proves each one against the plan, naming the pair that breaks it. It does not test one convenient host per VLAN: probe addresses are placed inside and just outside every firewall rule that cuts through a subnet, so a rule covering only part of a VLAN is caught. Violated policies also show up as errors in the design review.
Labs (Simulate → 🎓 Labs). Guided scenarios — inter-VLAN routing, guest isolation, OSPF between two sites, surviving a cut uplink — graded by proving the result in the simulator, not by comparing config text. Any configuration that makes the network behave as asked passes.
The firewall is stateful: devices track the connections they let through, and
a rule can match on it — access-list 130 permit ip any any established (IOS) or
connection-state=established,related (RouterOS). That is what makes a
one-directional policy possible ("Staff may reach Guest, Guest may not open
connections to Staff").
Firewall rules can be scoped the way real gear does it: ip access-group <n> in|out
on an interface (IOS) or in-interface= / out-interface= (RouterOS). An
access-list bound nowhere stays device-wide. OSPF/RIP only advertise interfaces
covered by a network statement (none at all = every interface); no router ospf
turns the protocol off.
More of the network is modelled:
- Spanning tree + redundant uplinks — give a switch a second uplink and STP
blocks one link of the loop (root = lowest priority, then id); cut the active
link and the backup takes over.
show spanning-treeshows port roles. - DHCP server and relay —
ip dhcp pool//ip dhcp-server network, andip helper-address//ip dhcp-relay. Once any device configures DHCP, a client only gets a lease if its VLAN's gateway serves a pool for that subnet or relays to a device in the plan that does (with nothing configured, every VLAN with a subnet still hands out leases). - A console that remembers — the device console keeps the simulated network
between commands, so
pingfollowed byshow arp,show mac address-table,show ip nat translationsshows what was learned. Plus?help, Tab completion,do,show interfaces,show access-lists,show ip protocols, ashow running-configthat includes everything configurable, and on RouterOS/export.
The RouterOS dialect is validated against real hardware (hAP ax lite, RouterOS 7.24.4).
Export ▾ → Device config / drift closes the loop between the drawing and the gear:
- Generate — pick a switch and get a RouterOS 7 script built from what the plan already holds: access ports with their VLAN, trunks, the VLAN table, the gateways an L3 switch hosts, its management address and static routes.
- Check drift — paste or upload the device's
/export(on the desktop app: Pull from device reads it over SSH) and Plexus lists where it no longer matches the plan: a port on the wrong VLAN, a VLAN missing from a trunk, a gateway that isn't configured, VLAN filtering switched off — plus anything on the device the plan doesn't know about.
Safe default / intended use: the script is for review and for devices you manage. Plexus never guesses a physical trunk port — you assign it in the dialog, and an unassigned trunk is left out and flagged rather than assumed. Bridge VLAN filtering is enabled as the last command; apply from the console or in Safe Mode.
- Remediate — when the device has drifted, Plexus writes the script that brings it back: it adds or corrects only what the plan requires and removes nothing.
Pull from device (desktop, MikroTik) is read-only by construction: it runs
ssh non-interactively with one fixed command (/export) chosen in the main
process — the page cannot supply a command — uses key or agent authentication
only, never prompts, and refuses a host key it has not seen (connect once with
Connect via SSH first). It asks before every connection.
-
Dry-run with rosconf (desktop) — hands the generated script (or the remediation script) to
rosconf: Plexus writes it to its own data directory and opens a terminal runningrosconf apply <host> -f <file>. That is a dry run: rosconf prints what it would send and changes nothing.Safe default, by construction: Plexus never passes
--apply. Pushing configuration to a device is your own step — re-run the printed command with--applyadded, after reading the dry-run output. The host, user, port and key go through the same validator as Connect via SSH, and therosconfexecutable is chosen once through a native file dialog and stored in the app's own settings — a project file cannot name a program to run. Intended for devices you own or are authorised to configure.
A router or gateway that has its own radio is placed with the switch/router tool, and Plexus gives it coverage like an access point: a wall-clipped ring, a share of the coverage percentage, and a place in the heatmap. The device panel shows Built-in WiFi with the standard, bands and planning range; untick it if the radio is switched off on site.
| Vendor | Models with a radio | Bands |
|---|---|---|
| Ubiquiti UniFi | UDM / Dream Machine, Dream Router | 2.4 + 5 GHz |
| Dream Router 7 | 2.4 + 5 + 6 GHz | |
| MikroTik | hAP mini, hAP lite, hAP, hAP ax lite, L009UiGS-2HaxD-IN | 2.4 GHz |
| hAP ac lite, hAP ac², hAP ac³, hAP ax², hAP ax³, RB4011iGS+5HacQ2HnD-IN | 2.4 + 5 GHz |
Everything else in the router and switch catalogue (UDM-Pro/SE, Cloud Gateways,
UXG, hEX, RB5009, CCR, every switch) is wired-only and gets no coverage. The
table lives in files/src/routerWifi.js, checked against the vendors' spec
pages; the range is a planning default (a desk-height router reaches a little
less than a ceiling AP of the same class), not a measurement.
The desktop app has a File menu — New, New from Template, Open, Open Recent, Save, Save As — and the window title shows the file name, with a dot while there are unsaved changes. Save writes back to the file you opened. The page can only read or write files you picked in a system dialog (or that are in the recent list); nothing in a project file can name a path.
- Export ▾ → Client report — a document for the person paying for the
network: predicted coverage per floor on the plan, on-site measurements where
there are any, the equipment list, cabling and video-storage totals, and a
sign-off block. It contains no IP or MAC addresses, VLANs, ports, internal
notes or credentials (those stay in the technical PDF). Written in Greek
when the project locale is
el-*. - New from template… (empty state, or File menu) — starts a project with the VLAN plan, reachability policies and naming convention for a villa, a hotel or a restaurant. The "must never reach" policies fail until the firewall rules exist — that is the to-do list. No floor plan or APs: those are the site.
- Other floors in the heatmap (Settings → Include other floors in heatmap) — APs on every other floor reach the current one through the slabs between: one slab loss per level and the true 3-D path length, using Floor-to-floor height. Floors are stacked in tab order and assumed to share a footprint.
The dialog also remembers the outcome of the last drift check per device ("matched the plan" / "N mismatches", with the time), saved with the project.
Goal: SSH into the physical device you clicked. Desktop app only.
- Give the device credentials. Select it → Credentials: set Protocol =
SSH, Host (defaults to the device IP), Port, Username, and an
optional SSH key path (e.g.
~/.ssh/id_ed25519). A 🔑 badge marks devices that are SSH-connectable. - Protect the file. In Settings → Credentials passphrase, set a passphrase
so credentials are encrypted at rest — a shared
.plexusnever leaks a password. (Entering Operate reminds you if plaintext passwords are present.) - Connect. Switch to Operate (confirm the prompt), then right-click the device → Connect via SSH. Your OS terminal opens a live session.
flowchart LR
RC["Right-click device"] --> M["Connect via SSH"]
M --> T["sshConnect.js<br/>build {host,user,port,key}"]
T --> P["preload bridge"]
P --> V["main.cjs · sshArgv.cjs<br/>validate + rebuild argv"]
V -->|valid| TERM["Terminal.app · gnome-terminal · Windows Terminal"]
V -->|hostile input| X["❌ rejected (fail closed)"]
Security model. The renderer only ever sends structured fields —
the main process re-validates them and rebuilds the ssh command itself, so a
hostile project file can't inject a shell command. No password is ever put on
the command line (key/agent auth, or ssh prompts in the terminal). The command
run is exactly:
ssh -i ~/.ssh/your_key -p 22 admin@192.0.2.10If a device connects as your local username instead of the one you expect, its Username field is empty —
sshfalls back to your OS login. Set it.
Plexus does not create tunnels; it runs your system's ssh. So any VPN that is
up on your computer works as it is: bring up the WireGuard or OpenVPN tunnel
with its own client, set the device's Host to the address that is reachable
through the tunnel (the device's LAN IP if the tunnel routes that subnet, or
its tunnel address), and Connect via SSH, Pull from device and Dry-run with
rosconf all go through it.
For a device behind a jump host instead of a VPN, add a Host block with
ProxyJump to your SSH client config and use that alias as the device's
Host — ssh resolves it; Plexus passes the name through unchanged.
Coverage modelling
- Wall-aware coverage — per-material dB attenuation (drywall/wood/glass/brick/ concrete) summed along 72 cast rays per AP → the real reachable polygon.
- Band-aware 2.4 / 5 / 6 GHz wall-loss multipliers; directional antennas (omni, ceiling, wall, sector 90/60/30°).
- Real heatmap (Web Worker) — RSSI / SNR / SINR / MCS / throughput, band-filtered.
- Channel widths 20–320 MHz (noise-floor + OFDMA-accurate); airtime/capacity checks.
- Propagation models — log-distance, ITU-R P.1238, COST-231 multi-wall.
- Regulatory regions (FCC/ETSI/JP/AU-NZ/IN/BR), roaming overlap, floor-to-floor leakage, auto channel/power/placement.
Network simulation (Packet-Tracer-class)
- Deterministic forwarding engine: L2/VLAN/MAC, ARP, L3 routing (longest-prefix, TTL), ICMP ping/traceroute, L4 probe.
- Inter-VLAN routing (L3 switch / SVIs / routed
/30uplinks). - Dynamic routing — OSPF (Dijkstra) and RIP (15-hop).
- Services — DHCP, name-based DNS, NAT/PAT, ACL/firewall, internet cloud.
- Device CLI — Cisco IOS + MikroTik RouterOS, running/startup config,
showcmds. - Animated PDU on the map + step inspector; wireless association via real RF; fault injection.
Live operation (desktop)
- Right-click → Connect via SSH (macOS/Linux/Windows terminal).
- Per-device credentials + optional SSH key; encrypted credentials vault.
- Fail-closed ssh-argv validation; no password on argv.
- UniFi controller sync (pull as-built / push channel-power); live WiFi survey.
Devices · planning · organization · deliverables
- Devices — AP/camera/switch catalogs (UniFi, MikroTik, Cisco, Aruba, Meraki, Hikvision, Dahua, Axis…), L2/L3 switches, wireless clients, walls, dead zones, SVG/DXF import, CV wall detection, DORI zones, NVR storage calculator.
- Planning — PoE budgets, cable runs, topology tree, survey CSV import, Ekahau
.esxinterop, AP-on-stick. - Organization — inventory & rollout table, IPAM + VLAN registry, port maps, naming convention, as-designed-vs-as-built diff, handover pack.
- Deliverables — branded PDF, BoM + cable-schedule CSV, per-AP install sheets, design-review comments, annotations, VLAN reachability matrix.
- Plan → device — RouterOS 7 config generated per switch, and a drift check
of a real
/exportagainst the plan.
| Key | Tool | Key | Tool |
|---|---|---|---|
| A | Add AP | M | Packet simulation |
| W | Switch / Router | K | Wireless client |
| C | Camera | L | Wall |
| D | Dead zone | N | Annotation |
| R | Ruler | V | Toggle coverage |
| H | Toggle heatmap | O | Toggle overlaps |
| G | Toggle grid | ? | Full cheatsheet |
The project model is compiled into a topology that a pure, headless engine
forwards packets over; the UI is a thin renderer, and the CLI folds back into the
same compile step so typed config changes what the next ping does.
flowchart TD
subgraph Model
P["Project model<br/>switches · APs · cameras · clients · VLANs"]
CLI["CLI console<br/>cli.js (IOS / RouterOS)"]
end
P --> C["simCompile.js<br/>model → topology"]
CLI --> C
C --> N["sim.js · buildNet()<br/>forwarding engine"]
subgraph ControlPlane["Routing control planes"]
OSPF["ospf.js"]
RIP["rip.js"]
end
OSPF --> N
RIP --> N
N --> EV["deterministic<br/>event stream"]
EV --> UI["simUI.js<br/>animated PDU + inspector"]
N --> WL["wireless.js<br/>best-AP association"]
Everything under files/src/ is pure and DOM-free, type-checked with
tsc --checkJs (JSDoc, no .ts rename), and has a sibling test in tests/.
Coverage polygons — for each AP we cast 72 rays (every 5°). Each ray sums
per-material dB loss × the AP's band factor (0.6 / 1.0 / 1.3 for 2.4 / 5 / 6 GHz)
and shrinks its reach by 0.5^(loss/3) — every 3 dB of attenuation roughly halves
range. The 72 endpoints form the cached coverage polygon.
Heatmap dBm — with a real-world Scale set, signal uses physical path loss:
RSSI(d) = EIRP − FSPL(1m) − 10·n·log₁₀(d) − Σ wall_dB
FSPL(1m) = 20·log₁₀(f_MHz) − 27.55 f = 2437 / 5500 / 6525 MHz
n = 2.2 (log-distance) · 3.0 (ITU indoor) · 2.0 (COST-231 + per-wall)
EIRP = Tx power + antenna gain − cable loss
See files/src/geometry.js (pure, unit-tested) and
docs/accuracy.md for predicted-vs-measured.
npm run build # → dist/ (open dist/index.html directly; file:// safe)
npm run app:build # → release/ (installer for the OS you're on)base: './' keeps the web build portable across http://, a CDN, or file://.
app:build only makes the current platform's installer; the GitHub Actions
matrix (.github/workflows/release.yml) builds all three on a v* tag — one
native runner per OS. App icons live in electron/resources/
(npm run make:icons, macOS only).
npm run verify # the full gate: vitest + tsc
npm run e2e:install # one-time: fetch the Playwright browser
npm run e2e # Playwright end-to-end suite (web build, dev server)
npm run e2e:desktop # builds, then drives the real Electron app (native bridge)691 unit tests across 50 files — RF geometry (incl. the physical FSPL model),
the forwarding engine (L2/L3, VLANs, ARP, routing, ACL, NAT, DHCP, DNS), OSPF
and RIP convergence, the IOS/RouterOS CLI engine, the project→sim adapter
(hardened against malformed/hostile project data), schema migration, crypto, the
SSH argv validator (injection-rejection cases), and the bundled sample project.
Also: structural validation of untrusted project files, the credentials vault,
the RouterOS config generator and drift check, controller certificate pinning
(against local self-signed HTTPS servers), property tests that check the IP math
against a BigInt oracle across the whole address space, and a ratchet that fails
on any unescaped interpolation into markup.
Also unit-tested: the undo history, deferred image deletion, the credentials
session (locked vaults survive a save), the project-file path gate and the
rosconf dry-run argv (no --apply, hostile targets rejected).
Plus a 5-test desktop E2E suite against the real Electron app — native
Open / Save / Save As / Open Recent, the path gate from the renderer's side, and
the rosconf hand-off — and a 29-test Playwright E2E suite (boot smoke + full scenario: load → place →
wall → coverage re-clips → export → re-import, the inventory/rollout/handover flow,
the simulation and device-config tooling, and security cases — hostile project
fields stay inert, encrypted saves leak no credentials, share links ask first).
files/
index.html UI shell
app.js App orchestrator (state, DOM, events, modes)
styles.css Theming + component styles
src/
geometry.js Pure RF math (ray-cast, dBm, SNR, MCS, propagation)
heatmap.js / heatmapWorker.js Heatmap model + Web Worker
network.js IP / subnet / CIDR + IPAM helpers
sim.js Forwarding engine (L2/L3, ARP, routing, ACL, NAT, cloud)
ospf.js / rip.js Dynamic-routing control planes
dns.js Name-resolution zone
cli.js / cliUI.js IOS/RouterOS config engine + per-device console
simCompile.js Project model → engine topology
simUI.js Packet-sim panel + animated PDU
wireless.js RF → best-AP association bridge
sshConnect.js Device → ssh target/command (renderer)
sshConfig.js ~/.ssh/config parse + device matching
constants.js AP / camera / switch catalogs, patterns, PoE, regions
migrate.js Schema migrations (v1 → v11)
imageStore.js / sampleProject.js / cameras.js / naming.js /
dxf.js / esx.js / walldetect.js / zip.js / i18n.js / i18n/en.js
electron/
main.cjs Windows, UniFi sync, WiFi survey, SSH launch
preload.cjs contextIsolated bridge (window.plexusNative)
sshArgv.cjs Validated ssh-argv builder (shell-injection boundary)
tests/ 30 vitest suites + e2e/ (Playwright smoke + scenario)
.github/workflows/ ci.yml (verify) · release.yml (installer matrix on v* tags)
vite.config.js vitest.config.js playwright.config.js tsconfig.json
Projects save as a single JSON file; floor-plan images live in IndexedDB,
referenced by id. Schema is versioned and the migrator reads every prior version —
current schema is v11 (files/src/migrate.js). Device credentials are stored in
the file only, excluded from Share links and reports, and encrypted when a project
passphrase is set.
- EIGRP and IPv6 in the simulator (today: static + OSPF + RIP, IPv4)
- Embedded SSH console in Operate mode (today: launches the OS terminal)
- Live state on the map from argus (link up/down, clients, PoE draw)
- EtherChannel and HSRP/VRRP
- Device config export for Cisco IOS and UniFi (today: RouterOS 7)
- Ekahau / NetSpot survey-file import (today: CSV only)
- Additional UI language bundles (English ships today)
PRs welcome — see CONTRIBUTING.md. Anything touching geometry,
the forwarding engine, the CLI, or schema versions needs a test in tests/.
See SECURITY.md to report something privately. Credentials are never logged in plaintext; the SSH launcher validates all input and fails closed.
A project file, share link or autosave is treated as untrusted input: it is structurally validated on load, every field is escaped before it reaches markup, and the page's CSP allows no inline script. With a credentials passphrase set, a saved project contains no plaintext credentials anywhere (revision snapshots never carry them). The desktop app pins a UniFi controller's certificate on first use — you approve the fingerprint once, and a changed certificate stops the connection before any credential is sent.
MIT — do whatever you want, just don't blame me when your boss asks why the coverage map said the conference room had signal.












