fiberpath 0.10.0

Plan, simulate, and manufacture composite parts with precision fiber winding.

Download · Documentation · Examples

Overview

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 winding mathematics — hoop and helical path generation, tow coverage, and machine kinematics for cylindrical mandrels — so you can focus on part design.

Features

• Visual Layer Editor – Design winding patterns with live preview
• Winding Path Planning – Automatic hoop, helical, and skip pattern generation for cylindrical mandrels
• Hardware Simulation – Validate motion before manufacturing
• Direct Machine Control – Stream G-code to Marlin controllers with pause/resume
• XAB-Native Axis Output – Standardized rotational-axis output with clear logical axis mapping
• 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

Scope & roadmap: FiberPath currently plans cylindrical mandrels with hoop, helical, and skip layers. Non-cylindrical (geodesic) surface support — including tapered and custom mandrels — is planned but not yet implemented.

Quick Start

Option 1: Desktop GUI (Recommended)

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.

Option 2: Command-Line Interface

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.

Installation

Desktop Application (Recommended)

📦 Download: github.com/fiberpath/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.

Python Package

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/fiberpath/fiberpath.git
cd fiberpath
uv pip install -e .[dev,cli,api]
pytest

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

Usage Examples

Planning a Winding Pattern

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

Visualizing Toolpaths (2D)

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

Simulating Jobs

# Simulation summary (time/material estimates; no interactive 3D viewer)
fiberpath simulate output.gcode

Streaming to Hardware

# 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

Streaming runs through the marlin-host library, which handles the connection handshake (waiting for Marlin's startup banner and negotiating capabilities) plus reliable line-numbered/checksummed framing. Press Ctrl+C to abort a live stream gracefully — it stops before the next line. Interactive pause/resume lives in the desktop GUI.

Using the Desktop GUI

The GUI provides two main workflows:

Main Tab:

• Visual layer editor with add/remove/reorder
• Real-time unwrapped toolpath 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

Development Workflow

# 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

Architecture

FiberPath is organized as a planning core and a machine-protocol library, fronted by three parallel interfaces (GUI, CLI, API):

┌─────────────────────────────────────────────────┐
│            Desktop GUI (Tauri + Svelte)          │
│  • Visual layer editor   • 2D preview canvas     │
│  • Machine control panel (connect/stream/e-stop) │
└───────────────────────┬──────────────────────────┘
                        │ HTTP (typed client; polls a job resource)
                        ▼
┌──────────────────────────────────────────────────┐
│   Local API sidecar (FastAPI) — bundled in app    │
│  • Planning / validation / plot endpoints         │
│  • Machine control: owns the serial port,         │
│    /machine/* routes + background job runner      │
└──────────┬─────────────────────────────┬──────────┘
           │ imports                      │ uses
           ▼                              ▼
┌────────────────────────────┐  ┌────────────────────────────┐
│      Core Engine (Python)   │  │  marlin-host (PyPI library) │
│  • Winding path planning    │  │  • Marlin serial-protocol   │
│    (hoop / helical / skip)  │  │    host: reliable framing,  │
│  • Layer strategies         │  │    handshake, M112 e-stop   │
│  • G-code generation        │  │                             │
└────────────────────────────┘  └────────────────────────────┘
           ▲                              ▲
           └──────────────┬───────────────┘
                          │ imports
┌─────────────────────────┴────────────────────────┐
│              CLI (Typer + Python)                  │
│  • plan   • plot   • simulate   • stream           │
└────────────────────────────────────────────────────┘

Design Principles:

• GUI, CLI, and API are parallel interfaces over the same Core Engine and marlin-host library
• The desktop GUI drives a bundled local API over HTTP — no separate server to run, and no bespoke subprocess protocol
• The sidecar owns the serial port; the GUI polls a job resource for streaming progress rather than holding the connection itself
• Machine I/O lives in marlin-host — a standalone, conformance-tested library, kept independent of FiberPath
• Core is deterministic and thoroughly tested
• Modular architecture lets each component be used independently

See Architecture Documentation for detailed design rationale.

Axis Configuration

FiberPath uses XAB rotational-axis output in built-in workflows:

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

Legacy XYZ programs should be re-generated under current versions. Simulation and plotting reject auto-detected XYZ files with an explicit error so stale programs are surfaced early.

Documentation

Comprehensive documentation is available at fiberpath.org/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

Contributing

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/fiberpath/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/Svelte follows the project type-check and lint 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.

License

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.