Repository files navigation

This application is a desktop client for theMeshtastic Project, designed to allow users to reliably manage large, decentralized mesh networks. Currently the Meshtastic client ecosystem has strong support for managing single nodes, but minimal support for network-level management and analysis. The goal of this project is to give users confidence in their Meshtastic networks as a reliable communications infrastructure through novel algorithmic analysis and connection-level insights.

We're looking for developers willing to contribute towards or take lead on the following major initiatives:

• Offline firmware flashing
• Full offline map support, including region-based downloading and loading of custom maps (will require Meshtastic mirror of theOSM tile DB)
• Testing (Rust backend, React TS frontend)
• Remote node configuration

This project is still in early stages of development, but here's a rough roadmap of functionality we're working on. We're placing a high priority on getting our core infrastructure right, since this is the core of any robust and effective UI layer.

• 🔗 Core dataflow infrastructure
  • Serial data send/receive
  • Rust protobuf integration (.proto -> .rs)
  • Packet encode/decode
  • Device state management
• 🎨 Core UI infrastructure
  • Tauri command management
  • Tauri event management
  • Redux saga dataflow
• 🛰️ Network topology collection
  • RFC for novel packet (completed)
  • MVP protobuf changes (completed)
  • MVP firmware changes (completed)
  • Community protobuf review (completed)
  • Community firmware review (completed)
• 🤓 Algorithmic analysis
  • Infrastructure
    • Network packet collation
    • Network graph construction
    • Algorithm runners
  • UI
    • MVP algorithm runner pane
    • On-map algorithm UI
    • Automatic algorithm rerunning
• 📻 Node management
  • Node peer table
  • Network configuration (multi-device)
  • Remote node configuration
• 📌 Waypoint management
  • Managed waypoint table
  • In-channel waypoint sending
  • On-map waypoint tooltip
• 🌐 Web client parity (UI)
  • Map node view
  • Messaging
    • Channel messaging
    • Direct messaging
  • Channel import/export via QR code
  • Configuration
    • Device configuration
    • Module configuration
    • Channel configuration
• 🗻 Offline map view
  • Offline map storage
  • Region-based downloading
• 📄 Network data export

This project is built on the Meshtastic hardware ecosystem, and as such this client requires that you have access to a Meshtastic radio.See theMeshtastic docs for hardware recommendations.

This project is built in Rust and React TypeScript, and managed using the PNPM package manager. As such, this project requires the following programs to be installed on your development machine:

• Rust Language
• Node.js
• PNPM Package Manager

To run this project locally, follow the steps below:

1. Ensure you have Rust, Node.js, and PNPM installed (seePrerequisites)
2. Ensure that you have allTauri dependencies installed (depends on your OS)
3. Clone this repositiory to a local directory. This can be done by runninggit clone https://github.com/meshtastic/network-management-client.git
4. Recursively clone our Git submodules by runninggit submodule update --init
5. Install all required NPM packages withpnpm i
6. Once you have completed these steps, verify your installation with thepnpm run rust:dev command. The application should compile successfully, and you should see the application open successfully. If this process fails for you, pleaselet us know!

While this project can be developed within any text editor, we recommend theVisual Studio Code editor. If using VSCode, we strongly recommend that you install the following Visual Studio Code extensions. These extensions both enforce code style and enable language and framework support for our tech stack.

• Biome - JavaScript LSP with formatting and linting
• rust-analyzer - Rust LSP with code linting, formatting, and quality suggestions

To standardize our development flow, we utilize PNPM commands, defined inpackage.json. These commands can be run with thepnpm run NAME ...ARGS syntax. Our commands are broken out into two primary categories,rust:* commands andui:* commands. Therust:* commands run the entire desktop application, where theui:* commands only run the UI layer.

Note: We strongly recommend against using theui:dev andui:build commands manually. These commands are invoked internally by therust:dev andrust:build commands, respectively. You willnot be able to connect to a serial devce when running theui:dev command, as this logic is not handled in the UI layer.

• pnpm run rust:dev - Starts the desktop application in development mode, allowing for hot reloading of UI and Rust code

• pnpm run rust:build - Builds the desktop application in production mode for your system architecture. Currently we only use this command for testing our application's CLI argument parser.

• pnpm run rust:test - Runs backend tests on the Rust codebase directory (/src-tauri). This command also generates TypeScript client bindings in the/src-tauri/bindings directory. Add-- --show-output to show Rustprintln! macro calls within test suites.

• pnpm run ui:dev - Starts the UI development server, allowing for UI development in a browser environment. Note that any code that interfaces with the Rust backendwill not function within this browser environment, meaning you will be unable to connect to serial devices in this context

• pnpm run ui:build: - Runs a production build on the UI code into thedist directory

• pnpm run ui:lint - Uses ESLint to check for code style errors. Note that our CI pipeline requires that this command succeeds before any changes can be merged

• pnpm run ui:format - Formats the UI codebase usingPrettier andESLint. We strongly recommend you run this before creating a PR!

• pnpm run ui:test - Runs UI test suite usingJest. Currently the project does not have a UI testing suite, but we're very open to contributions!

Note: On Linux, your user may not have permission to access a given serial port. If this happens, you will likely need to add your user to the group that controls the serial port you want to access. You can find the group that controls a serial port via thels -ld PATH_TO_PORT_HERE command. You can add your user to this group via theusermod -a -G GROUP_NAME_HERE $USER command.

As we are still very early in development, we don't yet have a standardized framework for accepting contributions. This being said, we are very open to suggestions and/or code changes! If you're interested in contributing to this repository, we would ask that you first check our issue board to ensure your work isn't duplicating the work of others. Then, please make an issue on our board so we know what you're interested in working on. If you have any questions about the project, we would love to hear from you!