Modalità CLI

wfas --server --viz --port 9090

wfas --server --viz --port 9090

[Unit]
Description=WFAS Audio Server
After=network.target

[Service]
ExecStart=wfas --server --viz --port 9090
Restart=on-failure

[Install]
WantedBy=multi-user.target

WiFi Audio Streaming 1.2.0  (c) 2026 Marco Morosi
Stream audio over your local network.

USAGE
  wfas [--gui | --cli] [--mode server|client|discover] [OPTIONS]
  wfas control <command>
  wfas config <command>
  wfas devices [--json]
  wfas pair <command>
  wfas firewall <command>
  wfas --help [<topic> | all]

TOPICS
  start        Getting started  modes, GUI vs CLI, discovery
  server       Server options  ports, capture engine, session, SDP
  client       Client options  output device, volume, microphone
  protocols    Streaming protocols  RTP, HTTP, DLNA, Snapcast
  network      USB & network  cable link, interfaces, IPv4/IPv6
  security     Security & pairing  encryption, keys, QR invites
  config       Configuration  settings, firewall, file locations
  runtime      Runtime & monitoring  control, status, visualizer, debug
  reference    Reference  protocol, updates, licenses, help itself

GETTING STARTED  modes, GUI vs CLI, discovery

One executable serves three roles: it captures this machine's audio and sends it out (server),
it receives audio from another machine and plays it (client), or it just scans the network to
see who is already streaming (discover). Without any flag wfas decides on its own: launched from
a terminal it prints a short hint, launched by a double click it opens the desktop app.

Entry point
  (no flags)            From a terminal, print a short hint. Otherwise open the GUI.

  --gui                 Open the desktop app.

                        Can be combined with a mode to open the window and start straight away,
                        as in 'wfas --gui --mode server --multicast'.

  --cli                 Stay in the terminal. Runs an audio server unless another mode is given.

  --no-tray             Start the GUI without the Linux tray icon.

                        Use this if the app segfaults inside libgtk-3 on launch; the tray is the
                        only part that touches GTK. Same as WFAS_NO_TRAY=1, or 'wfas config set
                        ui.linuxTray OFF' to make it permanent.

  --tray <auto|on|off>  Override the tray decision for this run. [auto]

                        auto looks for a StatusNotifierItem host on the session bus, which is
                        what KDE Plasma provides on both X11 and Wayland, and falls back to the
                        GTK status icon on X11. Use on to try anyway when the probe cannot reach
                        the bus. If the icon never appears on Wayland the usual cause is a
                        missing AppIndicator library: install libappindicator-gtk3 on Fedora,
                        libayatana-appindicator3-1 on Debian and Ubuntu.

Modes
  --server    Start as audio source. Shorthand for --mode server.
  --client    Start as audio receiver. Shorthand for --mode client.

  --mode <m>  server | client | discover

              server    capture this machine's audio and serve it
              client    receive audio from a server and play it
              discover  scan the network for active servers, then exit

Discovery
  Discovery is passive: servers announce themselves on the multicast group, so nothing is probed
  or port-scanned. Each entry reports the transport it was seen on and its address family.

  --watch  Keep scanning and update the list live instead of exiting after one pass.

           It applies to discovery and to 'wfas pair invite', the two views that would otherwise
           print once and exit. Anywhere else there is nothing to keep open, so wfas refuses the
           flag rather than ignoring it and falling back to starting a server.

Examples
  wfas --server                         # start a server, unauthenticated and in the clear
  wfas --client                         # receive from the first server found
  wfas --mode discover                  # list the servers on this network
  wfas --mode discover --watch          # keep the list updating
  wfas --mode discover --json           # scan and output JSON
  wfas --gui --mode server --multicast  # open the GUI and start serving immediately

See also: wfas --help server, wfas --help client, wfas --help network

SERVER OPTIONS  ports, capture engine, session, SDP

The server captures what this machine is playing and sends it out over the native WFAS protocol.
Everything here is about that native stream; the extra protocols that can run alongside it live
under 'Streaming protocols'.

Ports and delivery
  --port <n>          WFAS streaming port. [9090]
  --mic-port <n>      Port the microphone return channel comes back on. [9092]

  --multicast         Serve to every listener on the group instead of one unicast peer.

                      Implied by --rtp, --http, --dlna and --snapcast. Note that --auth-mode
                      applies to unicast only.

  --interface <name>  Network interface to bind and announce on. [Auto]

Session lifetime
  --persist  Keep the server up when a client disconnects, waiting for the next one. [off: a
             unicast server exits with its client]

             A unicast server normally serves one session and exits when that client leaves.
             With --persist the disconnect ends the session only: the port stays bound,
             discovery starts announcing again and the next client is served without restarting
             anything. Made for headless and systemd use, where Restart=always would otherwise
             bounce the whole process after every normal disconnect. The server then ends only
             when you end it: q on the terminal, Ctrl-C, or systemctl stop. Multicast has no
             per-client session and already behaves this way, so there the flag changes nothing.
             To make it the default: 'wfas config set server.persist true', or the switch in
             Settings > Startup & window. The flag then only matters for a run where the setting
             is off.

Capture engine
  --no-mute-render  Keep playing on this machine's speakers while streaming. [off: local
                    playback is muted for the session]

                    While capturing, the server mutes local playback so the same audio is not
                    heard twice, once from the speakers here and once from the client. What it
                    mutes is the render side, not the capture: the WASAPI render endpoint on
                    Windows, the default PulseAudio/PipeWire sink on Linux, the system volume on
                    macOS. The previous state is restored when the server stops. Pass
                    --no-mute-render to leave it alone and hear the audio in both places, e.g.
                    headphones on this machine and earbuds on the phone. Native engine only:
                    with --legacy-engine capture goes through a virtual cable, which takes the
                    audio off the speakers by itself.
                    To make it the default: 'wfas config set server.muteRender false', or the
                    switch in Settings > Audio Quality. The flag then only matters for a run
                    where the setting is on.

  --legacy-engine   Use the legacy FFmpeg grabber instead of the native C audio engine.

                    The native engine is the default on all platforms:
                      Windows  WASAPI loopback (no virtual driver needed)
                      macOS    ScreenCaptureKit
                      Linux    PulseAudio/PipeWire via dlopen
                    Use --legacy-engine on Linux if PulseAudio is unavailable, or for
                    compatibility with older setups. Alias: --no-native-engine.

Session descriptor
  An SDP file describes the stream well enough for VLC, ffplay or any RTP receiver to open it.
  Only meaningful together with --rtp.

  --sdp             Print stream.sdp to stdout when the server starts.
  --sdp-out <path>  Write stream.sdp to a file, for example /tmp/stream.sdp.

Examples
  wfas --server                   # start with the saved audio and network settings
  wfas --server --port 9500       # serve on a non-default port
  wfas --server --multicast       # serve every listener on the group
  wfas --mode server --rtp --sdp  # server plus RTP, printing the SDP
  wfas --server --persist         # stay up across client disconnects
  wfas --server --no-mute-render  # keep hearing the audio on this machine too
  wfas --server --legacy-engine   # fall back to the FFmpeg grabber

See also: wfas --help protocols, wfas --help security, wfas --help network

CLIENT OPTIONS  output device, volume, microphone

The client receives a WFAS stream and plays it on a local device. With no --connect it discovers
a server by itself and joins the first one it sees.

Connection and output
  --connect <ip>   Server address to connect to. Implies client mode. [auto-discover]

  --output <name>  Audio output device name. [system default]

                   Matching is partial and case-insensitive, so a fragment such as 'Loopback' is
                   enough. Run 'wfas devices' to see the exact names this system reports.

Playback
  --volume <0-100>  Initial volume percentage. [100]
  --mute            Start muted.

  --latency <ms>    Jitter buffer used on the Wi-Fi link. [120, range 0-5000]

                    Larger values survive a noisier network, smaller ones cut the delay. The USB
                    buffer is separate and is set by --usb-latency. Persists as audio.latencyMs
                    when saved with 'wfas config set'.

Microphone return channel
  Sends the client's microphone back to the server (talkback), independent of the main
  server-to-client audio stream.

  --mic               Enable the microphone return channel.
  --mic-input <name>  Microphone device name. Same partial matching as --output.

  --mic-routing <m>   mix | virtual | off [mix when --mic is given]

                      mix      blend the mic into the server's captured audio
                      virtual  expose the mic on the server as a virtual device
                      off      disable

Audio devices  (wfas devices)
  Lists every audio device Java Sound reports on this system, with the exact name to hand to
  --output or --mic-input, what each one can do, and why any of them was skipped. Alias:
  list-devices. Add --json for machine-readable output.

  devices  List the audio devices this system reports.

  A device is normally kept only if it answers a format probe. That probe opens the card, so it
  fails whenever another audio server (PulseAudio, PipeWire, JACK) holds it, which is common on
  Linux and on Raspberry Pi. When no device passes, wfas keeps the full list instead of leaving
  you with nothing, and 'devices' says so explicitly.

Examples
  wfas --client                          # join the first server found
  wfas --connect 192.168.1.5             # connect to a specific server
  wfas --client --output Loopback        # play into an ALSA loopback device
  wfas --client --volume 40              # start quiet
  wfas --client --latency 60             # trade robustness for a shorter delay
  wfas --client --mic --mic-routing mix  # talk back into the server's mix
  wfas devices                           # list audio devices and their exact names
  wfas devices --json                    # same, for scripts

See also: wfas --help runtime, wfas --help network, wfas --help config

STREAMING PROTOCOLS  RTP, HTTP, DLNA, Snapcast

Besides its own protocol the server can speak four standard ones at the same time, so receivers
that have never heard of WFAS can still play the audio. Each of these implies --multicast. None
of them is authenticated or encrypted: --auth-mode, --auth-key and --encrypt cover the native
WFAS stream only.

RTP
  Plain RTP for VLC, ffplay and hardware receivers. Pair it with --sdp so the receiver knows
  what it is getting.

  --rtp           Enable the RTP protocol. Implies --multicast.
  --rtp-port <n>  RTP port. [9094]

HTTP
  A plain HTTP stream any browser or media player can open by URL.

  --http           Enable the HTTP stream. Implies --multicast.
  --http-port <n>  HTTP port. [8080]
  --http-safari    Serve Safari-compatible AAC. Implies --http.

DLNA
  Pushes the audio to the DLNA renderers saved in the settings, so the renderer starts playing
  without anyone touching it.

  --dlna             Push audio to the saved DLNA renderers. Implies --multicast.
  --dlna-port <n>    DLNA media endpoint port. [8081]
  --dlna-format <f>  auto | lpcm | wav | mp3 | adts [auto]

Snapcast
  Acts as a Snapcast server for synchronised multiroom audio. Any snapclient on the network
  (Raspberry Pi, ESP32, Home Assistant, the Snapcast mobile apps) can join and stay in sync.

  --snapcast              Act as a Snapcast server. Implies --multicast.
  --snapcast-port <n>     Snapcast audio stream port. [1704]
  --snapcast-control-port <n>
                          Snapcast JSON-RPC control port. [1705]

  --snapcast-codec <c>    pcm | flac | opus [pcm]

                          flac roughly halves the bandwidth; opus needs 48000:16:2.

  --snapcast-chunk <n>    Chunk size in ms: 10 | 20 | 40 | 60 [20]
  --snapcast-buffer <n>   Client playback buffer in ms. [1000]
  --snapcast-name <s>     Stream identifier advertised to clients. [default]

Examples
  wfas --server --rtp --sdp                       # RTP plus the SDP on stdout
  wfas --server --http                            # listen from a browser on port 8080
  wfas --server --http-safari                     # AAC that Safari will play
  wfas --server --dlna                            # push to the saved DLNA renderers
  wfas --server --snapcast                        # synchronised multiroom audio
  wfas --server --snapcast --snapcast-codec flac  # half the bandwidth, same sync

See also: wfas --help server, wfas --help security, wfas --help runtime

USB & NETWORK  cable link, interfaces, IPv4/IPv6

How the audio physically gets across: over Wi-Fi, over the USB cable, or both, and which address
family to use.

USB link
  --usb               Stream over the USB cable instead of Wi-Fi.

                      Enable USB tethering on the Android phone: the phone becomes the gateway
                      and the app finds the link on its own. Lower and far steadier jitter than
                      Wi-Fi, which is what lets the buffer shrink. Not available on macOS: there
                      is no built-in RNDIS driver, so Android USB tethering does not come up.
                      Overrides the saved net.usbMode for this run.

  --no-usb            Force the USB link off even if it is enabled in the config.

  --usb-latency <ms>  Jitter buffer used only while the USB link is up. Implies --usb. [20,
                      range 5-120]

                      The Wi-Fi buffer set by --latency is left untouched.

  --usb-iface <name>  Force a specific tethering interface. Implies --usb.

                      Accepts the interface name or its display name as listed by --debug, or
                      'Auto' to restore automatic detection.

  --wfas-mode <m>     always | not-on-usb | off [not-on-usb]

                      When this device serves the native WFAS protocol:
                        always      always, over Wi-Fi and over the cable
                        not-on-usb  over Wi-Fi, but suppressed as soon as the USB link
                                    comes up
                        off         never over Wi-Fi; only the cable and the other
                                    protocols remain
                      With 'off' and no --rtp/--http and no USB link there is nothing left to
                      serve, and the server refuses to start.

Interface and address family
  --interface <name>  Network interface to bind and announce on. [Auto]
  --ip4, --ipv4       IPv4 only: bind 0.0.0.0, announce and listen on 239.255.0.1 alone.
  --ip6, --ipv6       IPv6 only: the [ff02::5746] group alone.

  Without either flag the app is dual-stack: it binds the wildcard, joins both groups, and picks
  per peer the most usable address, where a routable v4 or v6 beats a link-local. Force a family
  only to work around a broken network; on a v6-only LAN auto already does the right thing.

Examples
  wfas --server --usb                     # serve over the USB cable
  wfas --server --usb --usb-latency 10    # USB with an aggressive buffer
  wfas --server --usb --wfas-mode always  # keep Wi-Fi serving while the cable is up
  wfas --client --ip6                     # receive on an IPv6-only network
  wfas --server --interface eth0          # pin the server to one interface

See also: wfas --help server, wfas --help client, wfas --help config

SECURITY & PAIRING  encryption, keys, QR invites

Everything in this section applies to the native WFAS protocol only. RTP, HTTP, DLNA and
Snapcast are standard protocols: their clients are never authenticated and their audio always
goes out in the clear, so enabling them alongside --encrypt exposes the very audio you are
encrypting.

Authorization and encryption
  --auth-mode <m>         off | ask | key [off, unicast only]

                          off  accept anyone
                          ask  prompt on the terminal for each client that connects
                          key  require the pre-shared key

                          The security of a command line session comes from the command line,
                          and from nowhere else: a key set in the app protects the app, and
                          'wfas --server' starts in the clear whatever the app window says. That
                          way one command means one thing on every machine.

                          The other direction is explicit, so it is allowed: asking for key mode
                          without saying which key looks for one where you may have put it on
                          purpose - WFAS_AUTH_KEY first, then the system credential store, then
                          this terminal. None found, nothing starts.

  --ask-timeout <sec>     Only with --auth-mode ask: seconds before an unanswered client is
                          refused. [60, 0 waits forever]

                          The prompt appears on the terminal, or inside the visualizer panel
                          when --viz owns the screen. No terminal at all, or --json, means
                          nobody can answer: the client is refused and the reason is logged,
                          because a silent yes is not a decision anyone made.

  --auth-key <key|->      Pre-shared key. Implies --auth-mode key.

                          The key is never sent on the wire: both sides prove they hold it
                          through a mutual HMAC challenge-response. A key written inline is
                          readable in the process list for as long as wfas runs, and stays in
                          your shell history: pass - to read it from standard input instead, or
                          use --auth-key-file.

  --auth-key-file <path>  Read the pre-shared key from a file. Implies --auth-mode key.

                          The first non-empty line of the file is the key. Keeps it off the
                          command line and out of your shell history; set the file readable only
                          by you. WFAS_AUTH_KEY does the same through the environment.

  --encrypt               Encrypt the audio with ChaCha20-Poly1305.

                          Requires a key, so pair it with --auth-key, or use --qr to have one
                          generated. See 'wfas --protocol' for the wire details.

  --qr                    Generate a key, start encrypted, and print the pairing QR.

                          Server mode. Implies --auth-mode key and --encrypt, so it needs no
                          --auth-key: the code carries the key it just made. While the server
                          runs, p prints a new invite and r rotates the key.

                          That key lives in this process and nowhere else: it is never written
                          to the configuration or to the credential store, and it dies with the
                          server. An invite is worth something only while the server that issued
                          it is up, and the next one starts from a key nobody has seen before -
                          so a device paired once is not paired for good.

QR pairing  (wfas pair <command>)
  Hands a receiver everything it needs in one shot: address, port and a freshly generated
  256-bit key. The key is never typed and never travels on the wire; the invite carries it and
  the handshake proves it. Invites last 120 seconds.

  pair invite          Generate an invite and draw it as a QR code on the terminal.

                       With a server already running, the invite is generated by that instance
                       so it matches the live session; otherwise it is generated offline and
                       saved to the config, ready for the next 'wfas --server'. Add --watch for
                       a live countdown that renews the code on expiry: press n for a new
                       invite, r for a new key, k to reveal the key, q to quit.

  pair regenerate      Same, but always with a brand new key. Aliases: rekey, new-key.

                       In multicast this evicts every listener still using the old key, which is
                       exactly what you want after handing the code to the wrong person.

  pair connect <link>  Join using an invite link. Alias: join.

                       Accepts the wifiaudio://pair?... form or the https one. Starts the client
                       with the key already applied.

  pair inspect <link>  Decode a link and show what it contains, without connecting.

                       Exits non-zero if the invite has expired. Aliases: check, parse. Also
                       available as 'wfas inspect <link>'.

  pair encode <text>   Render any text as a QR code on the terminal. Alias: render.

                       Also available as 'wfas encode <text>'.

  pair status          Show pairing state, key origin and handler registration.
  pair off             Turn QR pairing off and restore the manually typed key. Alias: disable.

  pair register        Force-register the wifiaudio:// handler with this OS.

                       Per-user, no administrator rights. Every run already does this in the
                       background, rewriting the entry when it points at a different executable,
                       so moving or reinstalling the app repairs itself. Use this only to see
                       the repair fail loudly.

  pair unregister      Remove the wifiaudio:// handler.

QR rendering
  --no-qr     Print only the link, no ASCII art.

  --plain     Two characters per module instead of half-blocks.

              Use it if the terminal font has no U+2580/U+2584. Needs twice the width.

  --invert    Invert the code for terminals with a light background.
  --show-key  Print the pairing key instead of masking it.

Examples
  wfas --server --qr                          # start a server and show its pairing QR
  wfas pair invite --watch                    # live QR that renews itself on expiry
  wfas pair invite --json                     # the invite as JSON, for scripts
  wfas pair connect 'wifiaudio://pair?...'    # join from an invite link
  wfas pair inspect 'wifiaudio://pair?...'    # decode a link without connecting
  wfas pair regenerate                        # new key, evicts the old listeners
  wfas --server --auth-key hunter2 --encrypt  # encrypted with a key you chose

See also: wfas --help protocols, wfas --help reference

CONFIGURATION  (wfas config <command>)

Persistent settings live in a single config.json shared by the CLI and the GUI. Changes apply
the next time a server or client starts, or the next time the GUI opens.

Settings  (wfas config <command>)
  config list             Show every setting and its current value. Aliases: ls, show.
  config get <key>        Print one setting, for example audio.sampleRate.
  config set <key> <value>
                          Change one setting and save it.
  config path             Print the config.json path for this system. Alias: where.
  config edit             Open config.json in your default editor. Alias: open.
  config reset            Restore all settings to their defaults.
  config export [file]    Write the config to a file, or to stdout if omitted. Alias: save.
  config import <file>    Load a config.json and make it active. Alias: load.

  Add --json to any config command for machine-readable output.

Overrides
  --config <path>  Use an alternate settings file for this run.

Firewall  (wfas firewall <command>)   [Windows only]
  Opens the inbound UDP ports so clients can reach this machine, exactly like the button in the
  GUI settings. Prompts once for administrator approval. Alias: fw.

  firewall allow [ports]  Allow inbound UDP.

                          With no ports, opens the configured streaming, discovery (9091) and
                          mic ports. Or pass a list, as in 'wfas firewall allow 9090,9091'.

  firewall status         Show whether the WFAS firewall rule is active.

  Add --json for machine-readable output.

Examples
  wfas config list                        # show every setting and its value
  wfas config set audio.sampleRate 44100  # change a setting for both GUI and CLI
  wfas config get audio.latencyMs         # read one setting
  wfas config path                        # print the config.json path
  wfas config export backup.json          # save the current configuration
  wfas firewall allow                     # open the default ports in the firewall
  wfas firewall status                    # check if the firewall rule is active

See also: wfas --help network, wfas --help reference

RUNTIME & MONITORING  control, status, visualizer, debug

Talk to an instance that is already running, watch what it is doing, or look at the audio
itself.

Runtime control  (wfas control <command>)
  Sent over a local IPC socket to the running instance, GUI or CLI alike.

  control volume <0-100>  Set the output volume.
  control mute | unmute   Toggle audio output.
  control stop            Stop the running instance.

  control status          Show the current streaming status.

                          Includes the RTP, HTTP, DLNA and Snapcast side-protocols and their
                          connected clients.

Visualizer
  --viz [theme]      Animated ASCII spectrum histogram of the audio stream.

                     Optional theme: a hex color such as #1e88e5 recolors the whole view via the
                     Material You palette, or 'rainbow' for an animated dynamic rainbow.

  --groove [amount]  Only with --viz: adaptive spectrum that follows the melody.

                     Instead of drawing raw levels, where bass pins the low bars at full scale
                     and everything else flattens into one blob, each band is compared with its
                     frequency neighbours, so a note that pokes out of its region is lifted, and
                     a slow per-band envelope is subtracted, so the constant part of the mix
                     stops dominating. Optional amount: soft | normal | hard, or 0-160. Press g
                     in the visualizer to toggle it live.

  --monitor          Only with --viz: no server, just visualize the system audio. Alias:
                     --listen.

                     Reads the loopback without lowering the system volume.

Diagnostics and output
  --debug   Live debug HUD, then internal logs.

            Audio packet table plus, with --mic, the microphone send/receive table. Also lists
            the network interfaces by name and display name, which is what --usb-iface expects.

  --json    Emit all output as JSON.

  --reveal  Print secret config values instead of masking them.

            Secrets such as security.authKey are shown as ******** by 'config list', 'config
            get' and 'config export', so they do not end up in terminal scrollback, shell
            history or a shared export by accident. Pass --reveal when you actually need the
            value, and treat whatever it lands in as a secret. It prints only to an interactive
            terminal: redirected output and --json are refused, and 'config export --reveal'
            asks for confirmation before writing secrets in plain text. For unattended use pass
            the key through WFAS_AUTH_KEY instead. Note that this guards against accidents, not
            against a hostile program: anything running as your user can read the same secret
            straight from the credential store.

  --quiet   Suppress logs; only errors go to stderr.

Examples
  wfas control volume 75         # set volume on the running instance
  wfas control status            # what is streaming right now
  wfas control status --json     # same, for scripts
  wfas control stop              # stop the running instance
  wfas --viz rainbow             # spectrum with animated rainbow colors
  wfas --viz "#1e88e5"           # spectrum themed from a hex color
  wfas --viz --monitor           # spectrum of the system audio, no server
  wfas --viz --monitor --groove  # same, adaptive: follows the melody
  wfas --viz --groove hard       # maximum contrast between notes
  wfas --server --debug          # serve with the debug HUD

See also: wfas --help client, wfas --help config

REFERENCE  protocol, updates, licenses, help itself

Documentation
  --protocol     Explain the WFAS v2 wire protocol and exit.
  --licenses     Show third-party open-source licenses and exit. Aliases: --license, --credits.
  --version, -v  Show the version and exit.

Updates
  --check-update          Check GitHub for a newer release and exit. Alias: --check-updates.

  --auto-check-update on|off
                          Enable or disable the automatic update check at startup.

                          Equivalent to 'wfas config set app.autoCheckUpdate on|off'.

Help itself
  --help, -h      Open the interactive help browser.

                  Falls back to the complete text whenever the output is not an interactive
                  terminal, so 'wfas --help > help.txt' and 'wfas --help | grep snapcast' both
                  give you everything. Set WFAS_NO_INTERACTIVE=1 to force that fallback.

  --help all      Print every section at once, never interactive.
  --help <topic>  Print one section. Topics: start, server, client, protocols, network,
                  security, config, runtime, reference
  --help --json   Emit the whole option table as JSON, for completions and docs.

Examples
  wfas --protocol         # print the WFAS v2 protocol reference
  wfas --help snapcast    # jump straight to the Snapcast options
  wfas --help all | less  # read the whole thing in a pager
  wfas --check-update     # see if a newer release exists

See also: wfas --help start

FILES
  /home/user/.config/wfas/config.json  settings file
  /tmp/wfas-<pid>.port                  IPC port file
  /tmp/stream.sdp                       RTP descriptor

  Override the settings file with --config <path>, or print it with 'wfas config path'.

See 'man wfas' for the same reference as a manual page.

Licensed under the EUPL, Version 1.2
  Desktop source:    https://github.com/marcomorosi06/WiFiAudioStreaming-Desktop
  Android app:       https://github.com/marcomorosi06/WiFiAudioStreaming-Android
  WFAS v2 protocol:  https://github.com/marcomorosi06/wfas-protocol