https://github.com/flexcompute/flexfoil
A 2D panel code with integral boundary layer based on Mark Drela's tools
https://github.com/flexcompute/flexfoil
Last synced: 3 months ago
JSON representation
A 2D panel code with integral boundary layer based on Mark Drela's tools
- Host: GitHub
- URL: https://github.com/flexcompute/flexfoil
- Owner: flexcompute
- License: mit
- Created: 2026-01-16T00:01:42.000Z (5 months ago)
- Default Branch: main
- Last Pushed: 2026-03-26T12:51:43.000Z (3 months ago)
- Last Synced: 2026-03-27T04:52:31.129Z (3 months ago)
- Language: Rust
- Size: 16.6 MB
- Stars: 7
- Watchers: 0
- Forks: 1
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# FlexFoil
A 2D panel code with integral boundary layer based on Mark Drela's tools - modern, high-performance airfoil analysis engine written in Rust, compiling to WebAssembly for real-time (60 Hz) web-based interaction.
## Overview
FlexFoil (RustFoil core) is a ground-up rewrite of Mark Drela's XFOIL, architected from the start to support:
- **Multi-body configurations** (slats, main wing, flaps)
- **Real-time feedback** during geometry manipulation
- **WebAssembly output** for browser-based UIs
- **Modern Rust idioms** with strong type safety
## Architecture
```
┌─────────────────────────────────────────────────────────────────┐
│ Applications │
├─────────────────────┬─────────────────────┬─────────────────────┤
│ rustfoil-wasm │ rustfoil-cli │ flexfoil-ui │
│ WASM/JS bindings │ Dev/testing CLI │ React frontend │
├─────────────────────┴─────────────────────┴─────────────────────┤
│ rustfoil-solver │
│ • Inviscid panel method (Phase 2) │
│ • Boundary layer equations (Phase 3) │
│ • Viscous-inviscid interaction (Phase 4) │
├─────────────────────────────────────────────────────────────────┤
│ rustfoil-core │
│ • Geometry types (Point, Panel, Body) │
│ • Cubic spline interpolation │
│ • Coordinate I/O │
└─────────────────────────────────────────────────────────────────┘
```
## Project Structure
```
flexfoil/
├── Cargo.toml # Workspace root
├── crates/
│ ├── rustfoil-core/ # Geometry, splines, core types
│ ├── rustfoil-solver/ # Panel method, BL, VII
│ ├── rustfoil-wasm/ # WebAssembly bindings
│ └── rustfoil-cli/ # Command-line tool
├── flexfoil-ui/ # React + TypeScript frontend
└── testdata/ # Sample airfoil files
```
## Quick Start
### Build
```bash
# Build all crates
cargo build --release
# Run tests
cargo test
# Build WASM (requires wasm-pack)
cd crates/rustfoil-wasm
wasm-pack build --target web
```
### Frontend
```bash
cd flexfoil-ui
npm install
npm run dev
```
### CLI Usage
```bash
# Analyze an airfoil at 5° angle of attack
cargo run --bin rustfoil -- analyze testdata/naca0012.dat --alpha 5.0
# Generate a polar
cargo run --bin rustfoil -- polar testdata/naca0012.dat --alpha-start -5 --alpha-end 15
# Repanel with cosine spacing
cargo run --bin rustfoil -- repanel testdata/naca0012.dat --panels 100
```
### WASM Usage (JavaScript)
```javascript
import init, { RustFoil, analyze_airfoil } from 'rustfoil-wasm';
await init();
// Quick one-shot analysis
const coords = [1.0, 0.0, 0.5, 0.1, 0.0, 0.0, 0.5, -0.1, 1.0, 0.0];
const result = analyze_airfoil(coords, 5.0);
console.log(`Cl = ${result.cl}`);
// Interactive usage
const foil = new RustFoil();
foil.set_coordinates(coords);
foil.set_alpha(5.0);
const solution = foil.solve();
```
## Development Phases
### Phase 1: Foundation
- [x] Geometry types (`Point`, `Panel`, `Body`)
- [x] Cubic spline interpolation
- [x] XFOIL-exact NACA generator
- [x] XFOIL-exact paneling (PANGEN)
- [x] WASM bridge
- [ ] Coordinate file I/O (Selig, Lednicer formats)
### Phase 2: Inviscid Solver (Current)
- [x] Linear vorticity panel method (PSILIN)
- [x] Kutta condition
- [x] Blunt TE handling
- [x] XFOIL-exact Cl/Cm
- [ ] Wake modeling
- [ ] Multi-body interactions
- [ ] Real-time Cp display
### Phase 3: Boundary Layer
- [ ] Thwaites method (laminar)
- [ ] Head/Green method (turbulent)
- [ ] Transition prediction (eN)
- [ ] Separation detection
### Phase 4: Viscous-Inviscid Interaction
- [ ] Global Newton-Raphson
- [ ] Transpiration velocity
- [ ] Convergence acceleration
### Phase 5: Advanced Features
- [ ] Multi-body viscous
- [ ] Wake interaction
- [ ] Inverse design
## Technical Details
### Coordinate Convention
- **X-axis:** Downstream (freestream direction). LE at x≈0, TE at x≈1.
- **Y-axis:** Upward. Upper surface has positive y.
- **Panel ordering:** Counter-clockwise from TE lower to TE upper.
### Dependencies
- `nalgebra` - Linear algebra (SIMD-optimized)
- `wasm-bindgen` - JavaScript interop
- `serde` - Serialization for WASM
### Performance Targets
- Inviscid solve: < 16ms for 200 panels (60 Hz capable)
- WASM bundle: < 500 KB gzipped
## References
1. Drela, M. "XFOIL: An Analysis and Design System for Low Reynolds Number Airfoils" (1989)
2. Katz, J. & Plotkin, A. "Low-Speed Aerodynamics" (2001)
3. Cebeci, T. & Bradshaw, P. "Momentum Transfer in Boundary Layers" (1977)
4. Fidkowski, K. J. "A Coupled Inviscid-Viscous Airfoil Analysis Solver, Revisited," *AIAA Journal*, Vol. 60, No. 5, 2022, pp. 2961–2971. [doi:10.2514/1.J061341](https://doi.org/10.2514/1.J061341)
## License
FlexFoil is licensed under the [MIT License](LICENSE).
Copyright (c) 2026 Flexcompute, Inc. and Harry Smith.
This repository includes third-party components and references commercial
dependencies. See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for details
on AG Grid Enterprise, the TWK Everett typeface, and other attributions.