Current Release: v1.2.2 (full changelog)
This project is developed in my spare time alongside full-time post-secondary studies (and, as of mid-2026, a capstone thesis). Development is driven by learning objectives, research interest, and available time, so updates are irregular in cadence but not in seriousness — every release fixes or improves the actual electromagnetic modeling, not just UI polish. See Status below for what's currently open.
SpecterCS is a real-time radar cross-section (RCS) simulation platform built in C#. It models electromagnetic scattering using Physical Optics (PO) and edge diffraction (UTD/PTD-inspired) techniques, with support for parallel CPU computation and GPU acceleration.
The system provides interactive 3D visualization, enabling analysis of radar signatures across varying frequencies, azimuth, and elevation angles.
Active software running using a model of an Airbus A320 NEO
Model: https://www.printables.com/model/552457-airbus-a320-neo/files
-
High-Fidelity RCS Computation
- Physical Optics using an exact planar-polygon phase integral (Stokes'-theorem boundary formulation, replacing the earlier Ling–Lee–Chuang centroid-based approach in v1.2.2)
- Edge diffraction using UTD/PTD-inspired models with Fresnel transition functions
- Coherent phase-based summation across surfaces and edges
- Broadside limit handling for constant-phase facets
-
Material & Electromagnetic Modeling
- Perfect Electric Conductor (PEC) surfaces
- Dielectric and Radar Absorbing Material (RAM) coatings
- Fresnel-based reflection with complex permittivity/permeability
- Built-in material presets: PEC, Aluminium, Titanium Alloy (v1.2.1+)
-
Hybrid Compute Architecture
- Multi-threaded CPU engine for accurate physics computation
- GPU acceleration (ComputeSharp) for real-time visualization
- Coherent CPU results + approximate GPU heatmap rendering
-
3D Visualization
- Interactive 3D viewport (HelixToolkit)
- Per-facet RCS heatmap (dBsm)
- Real-time parameter updates
-
Geometry Processing Pipeline
- OBJ and STL import (STL strongly recommended — see Model Prep)
- Automatic triangulation
- Edge extraction with dihedral angle computation
- Level-of-detail (LOD) mesh decimation
-
Radar Simulation
- Configurable frequency (GHz range)
- Full azimuth/elevation control
- Polarization support (HH, VV, HV, VH)
- Real-time sweep computation
-
Caching & Performance Optimization
- Angular and frequency quantization
- Polarization-aware caching
- Fast recomputation for interactive workflows
SpecterCS is structured as a modular system:
Echo1_Core (SpecterCS_Core.csproj)
├── Engine # RCS computation: PhysicalOpticsKernel, EdgeDiffractionKernel, RcsEngine, RcsCache, BackFaceCuller, MaterialProperties
├── Geometry # RcsMesh, Facet, BoundingBox, Vector3d, MeshDecimator (LOD)
├── Radar # RadarConfig, FrequencyBand, RadarSweepState
├── Import # ObjImporter, StlImporter
└── GPU # GpuRcsCompute, RcsShader, FacetGpuData
Echo1_Wpf (SpecterCS_Wpf.csproj)
├── Rendering # SceneBuilder, FreeFlyCamera, HeatmapColorMap, FacetMaterialCache
├── Controls # RadarSweepControl, RcsPolarPlot
└── ViewModels # MainViewModel, HeatmapViewModel, RadarConfigViewModel (MVVM)
Surface scattering is computed using an exact planar-polygon phase integral, derived via a Stokes'-theorem boundary integral (replacing the earlier per-triangle Ling–Lee–Chuang analytic integral as of v1.2.2, for better numerical behavior on large/near-broadside facets).
Key characteristics:
- Exact phase integration across facet boundaries
- Coherent summation of scattered fields
- Correct amplitude normalization (k² scaling)
- Material-dependent Fresnel reflection
- Explicit broadside-limit handling for constant-phase facets
Edge contributions are modeled using a Uniform Theory of Diffraction (UTD)-inspired approach, using an edge-weighted term (EdgeTerm, replacing the earlier EdgeIntegral as of v1.2.2) for improved handling of degenerate geometry:
- Wedge-based diffraction using dihedral angles
- Kouyoumjian–Pathak transition function for boundary smoothing
- Fresnel integral evaluation (series, asymptotic, and numerical quadrature)
- Monostatic coherent edge integration
Electromagnetic interaction is modeled via:
- Fresnel reflection coefficients (angle + polarization dependent)
- Complex permittivity and permeability
- Single-layer RAM coating approximation using impedance methods
- Preset materials: PEC, Aluminium, Titanium Alloy
- .NET 6 or later
- Windows (required for GPU acceleration)
- GPU with DirectX 12 support (optional but recommended)
- Download the latest release archive
- Unzip archive (do not move the .exe out of the folder — it depends on relative paths for assets/dependencies)
- Double-click
Echo1.Wpf.exe - Enjoy
This section exists to answer the most common setup questions (mesh format, materials, prerequisites).
OBJ files are not recommended. Many OBJ exports have topology and vertex-connectivity issues (non-manifold edges, duplicate/loose vertices) that the importer can't always catch, and these produce inflated, non-physical RCS values. This is a known, currently unresolved limitation (see Status).
For reliable results:
- Export or convert your model to STL
- Make sure the mesh is manifold (closed, watertight, no self-intersections) — most CAD tools have a "check/repair mesh" or "make manifold" function
- Use consistent metric units — the importer assumes meters
- Click "Load OBJ / STL"
- Select your mesh file
- The system will import geometry, build edges, generate LODs, and begin real-time simulation
- Known first-load issue: RCS values may appear impossibly high immediately after load. Move the elevation slider once to force a recompute — this resolves it. Root cause is still under investigation (see Status).
- Built-in presets: PEC (perfect conductor, theoretical upper-bound RCS), Aluminium, Titanium Alloy
- Materials are modeled via complex permittivity (εr) and permeability (μr); RAM/dielectric coatings use a single-layer Fresnel impedance approximation — multilayer (TMM) coatings are not yet supported.
- Custom coatings are not planned to be implemented due to legal reasons.
If you're looking for these, they're planned but not built — don't spend time trying to find them in the UI:
- Fluid/thermal simulation and EM-thermal-fluid coupling
- Non-linear, spatially-variant surface impedance boundaries
- Multi-bounce (SBR) scattering — current engine is single-bounce PO + edge diffraction only
- Multilayer material coatings (TMM)
- Facet specific material overrides
| Control | Function |
|---|---|
| Mouse (Right Click + Drag) | Rotate camera |
| W / A / S / D | Move camera |
| Q / E | Vertical movement |
| Shift | Faster movement |
- RCS (dBsm) — logarithmic radar signature
- RCS (m²) — linear radar cross-section
- Heatmap Visualization — per-facet contribution
Known open issues (as of v1.2.2):
- OBJ files can still return inflated RCS values due to mesh-topology limitations — use STL (see Model Prep)
- On first load, RCS values may appear impossibly high until the elevation slider is moved once — root cause not yet identified
Current engine limitations:
- Diffraction model is UTD-inspired, not a full multi-bounce diffraction solution
- No multiple scattering (single-bounce PO + edge diffraction only)
- Limited validation against measured RCS datasets
- GPU path uses centroid-based approximation (CPU path is authoritative)
- No time-domain or transient simulation
Done:
- Advanced diffraction models (UTD, exact planar-polygon PO)
- Material and dielectric modeling
- Polarization handling (HH, VV, HV, VH)
- Material presets (PEC, Aluminium, Titanium Alloy)
- Polar RCS plots (
RcsPolarPlotcontrol)
Planned:
- Fix OBJ import inflation and first-load RCS bug
- Bi-directional multiphysics coupling (EM–thermal–fluid)
- Non-linear, spatially-variant surface impedance (Zs) boundaries
- Fluidic-embedded substrate homogenization
- High-G dynamic loading, deformable mesh
- Quantum capacitance (Cq) graphene models
- Galinstan oxidation layer modeling
- Time-domain simulation
- Cloud / distributed computation
- AI-assisted stealth optimization
SpecterCS is built around three principles:
- Clarity — visualize complex electromagnetic behavior intuitively
- Performance — leverage parallelism and GPU acceleration
- Extensibility — modular design for future expansion
- Uses analytic electromagnetic formulations, not heuristic approximations
- Separates visualization (GPU) from physics computation (CPU)
- Supports material-aware RCS modeling, not just geometry-based scattering
- Designed as a modular simulation engine, not a single-purpose tool
This project is intended for educational, research, and visualization purposes only. It is not a validated engineering tool and should not be used for real-world defense or safety-critical applications.
Developed by Mathew Dixon