FiberPath automates the complex process of filament winding—wrapping fiber-reinforced composites around mandrels to create lightweight, high-strength cylindrical parts like pressure vessels, pipes, and aerospace structures.

Design multi-layer winding patterns in a visual interface, simulate the full manufacturing process, and stream G-code directly to Marlin-based hardware. FiberPath handles the mathematics of geodesic paths, fiber tension calculations, and machine kinematics so you can focus on part design.

• Visual Layer Editor – Design winding patterns with real-time 3D preview
• Geodesic Path Planning – Automatic computation of stable fiber trajectories
• Hardware Simulation – Validate motion before manufacturing
• Direct Machine Control – Stream G-code to Marlin controllers with pause/resume
• Flexible Axis Mapping – Support for XAB rotational or XYZ linear axis configurations
• Cross-Platform Desktop GUI – Native Windows, macOS, and Linux applications
• Command-Line Tools – Scriptable workflows for automation and CI/CD
• Comprehensive Documentation – Architecture guides, examples, and API reference

Download the installer for your platform from the latest release:

• Windows: .msi or .exe installer
• macOS: .dmg disk image
• Linux: .deb package or .AppImage

Launch the application, load an example from the File menu, and explore the visual editor.

Install via pip or uv:

pip install fiberpath
# or
uv pip install fiberpath

Generate G-code from an example:

fiberpath plan examples/simple_cylinder/input.wind -o simple.gcode
fiberpath plot simple.gcode --output simple.png

The plot command creates a 2D unwrapped visualization of the toolpath for quick inspection.

📦 Download: github.com/CameronBrooks11/fiberpath/releases/latest

No Python installation required—the GUI is a fully self-contained native application with the FiberPath backend bundled inside. Just download, install, and run.

• Windows: .msi or .exe installer
• macOS: .dmg disk image
• Linux: .deb package or .AppImage

All desktop installers include the complete FiberPath toolchain for planning, simulation, and streaming.

Requirements: Python 3.11+

# Install from PyPI
pip install fiberpath

# Install with optional dependencies
pip install fiberpath[cli]  # CLI tools
pip install fiberpath[api]  # FastAPI server
pip install fiberpath[dev]  # Development tools

Development Install:

git clone https://github.com/CameronBrooks11/fiberpath.git
cd fiberpath
uv pip install -e .[dev,cli,api]
pytest

💡 Using uv is recommended for faster installs, but standard pip works fine.

# Generate G-code from a .wind configuration
fiberpath plan examples/simple_cylinder/input.wind -o output.gcode

# Specify axis format for your machine
fiberpath plan input.wind -o output.gcode --axis-format xab

# Create 2D unwrapped plot
fiberpath plot output.gcode --output preview.png --scale 0.8

# Interactive 3D simulation (GUI)
fiberpath simulate output.gcode

# Test streaming without hardware connection
fiberpath stream output.gcode --dry-run

# Connect and stream to Marlin controller
fiberpath stream output.gcode --port COM5 --baud-rate 250000

FiberPath automatically waits for Marlin's startup sequence (M92, M203, etc.) before streaming. Use Ctrl+C to pause—FiberPath issues M0 and resumes with M108.

The GUI provides two main workflows:

Main Tab:

• Visual layer editor with add/remove/reorder
• Real-time 3D canvas preview
• Parameter forms for mandrel, tow, and machine settings
• Export to G-code or save as .wind project file

Stream Tab:

• Serial port selection and connection management
• Manual G-code command input for testing
• File streaming with pause/resume/cancel controls
• Real-time position tracking and status updates

# Run GUI in development mode
cd fiberpath_gui
npm install
npm run tauri dev

# Run tests
pytest                           # Python tests
cd fiberpath_gui && npm test     # TypeScript tests

# Run API server
fiberpath-api --port 8000        # Requires fiberpath[api] install

FiberPath consists of four coordinated components:

┌─────────────────────────────────────────────────┐
│              Desktop GUI (Tauri + React)        │
│  • Visual layer editor                          │
│  • 3D canvas preview                            │
│  • Serial communication controls                │
└───────────────┬─────────────────────────────────┘
                │ IPC calls
                ▼
┌─────────────────────────────────────────────────┐
│           CLI (Typer + Python)                  │
│  • plan   • plot   • simulate   • stream        │
└───────────────┬─────────────────────────────────┘
                │ imports
                ▼
┌─────────────────────────────────────────────────┐
│           Core Engine (Python)                  │
│  • Geodesic path planning                       │
│  • Layer strategies                             │
│  • G-code generation                            │
│  • Geometry utilities                           │
└─────────────────────────────────────────────────┘
                ▲
                │ imports
┌───────────────┴─────────────────────────────────┐
│           API Server (FastAPI)                  │
│  • RESTful planning endpoints                   │
│  • JSON input/output                            │
│  • Optional deployment for web integration      │
└─────────────────────────────────────────────────┘

Design Principles:

• CLI and API are parallel interfaces to the same Core Engine
• GUI calls CLI via IPC for offline operation (no server required)
• Core is deterministic and thoroughly tested (113 passing tests)
• Modular architecture allows using components independently

See Architecture Documentation for detailed design rationale.

FiberPath supports two axis mapping formats:

XAB (Rotational) - Default:

• X = Carriage position (linear, mm)
• A = Mandrel rotation (rotational, degrees)
• B = Delivery head rotation (rotational, degrees)

XYZ (Legacy):

• X = Carriage position (linear, mm)
• Y = Mandrel rotation (treated as linear, degrees)
• Z = Delivery head rotation (treated as linear, degrees)

Use --axis-format xab (default) for new projects. The XYZ format maintains compatibility with legacy systems like Cyclone.

Comprehensive documentation is available at cameronbrooks11.github.io/fiberpath:

• Getting Started Guide – Installation and first steps
• Architecture Overview – System design and components
• Usage Guides – Visualization, streaming, WIND format
• API Reference – Core functions and CLI commands
• GUI Documentation – Desktop application architecture
• Development Guide – Contributing, tooling, release process

Contributions are welcome! FiberPath is actively developed and maintained.

Before contributing:

1. Read the Contributing Guide
2. Check existing issues and pull requests
3. Open an issue to discuss major changes before implementing

Development setup:

git clone https://github.com/CameronBrooks11/fiberpath.git
cd fiberpath
uv pip install -e .[dev,cli,api]
pytest

cd fiberpath_gui
npm install
npm test

Code standards:

• Python code follows PEP 8 (enforced by CI)
• TypeScript/React follows project ESLint configuration
• All new features require tests and documentation
• Commit messages use conventional commits format

See Development Documentation for tooling, CI/CD, and release process details.

FiberPath is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0).

This means:

• ✅ Free to use, modify, and distribute
• ✅ Source code must be made available to users
• ⚠️ Network use (e.g., hosting as a service) triggers copyleft

See LICENSE for full terms.

Questions? Open an issue or check the documentation.

Found a bug? Report it on GitHub Issues with steps to reproduce.