Service · Software development

Custom CAE software development.

Custom Computer Aided Engineering: from custom physics solvers in C++ and Fortran to pre- and post-processing tooling around ANSYS, Abaqus and OpenFOAM. For engineering teams that are hitting the limits of their standard package and need specialist simulation that is accurate for their product, sector or client.

FEA & CFDCustom solversHPC & GPUC++ / Fortran

We don't replace ANSYS — we complement it where the package stops.

Computer Aided Engineering is a broad field: Finite Element Analysis for structural calculations, Computational Fluid Dynamics for fluid flow, electromagnetic simulation for antenna and motor design, multibody dynamics, acoustics, thermal analysis. For the majority of standard questions, ANSYS, Siemens Simcenter, Dassault Simulia (Abaqus), Altair HyperWorks, MSC, COMSOL Multiphysics and OpenFOAM are excellent choices. We don't rebuild those packages.

We come into the picture as soon as something specific is needed that no vendor supplies: a solver for sector-specific physics, automation around an existing pipeline, a web portal that makes simulation accessible to non-engineers, or a C++ codebase that runs on a GPU cluster. In particular, building manufacturing software and simulation tooling around enterprise systems overlaps strongly with this service. For construction-related modelling we often see overlap with BIM software, and for connecting to the shop floor with MES systems.

Three types of CAE project.

Most work falls into one of these three categories. In the first session we decide together which one fits your problem.

Compact project · fixed sprint budget

Scripting & automation around existing packages

ANSYS APDL scripts, Abaqus Python API, COMSOL LiveLink, OpenFOAM dictionary generators. Repetitive setup, batch runs and post-processing fully automated, including integration with your PLM or issue tracker. The simulation keeps running in the vendor package — we build the layer around it that helps your team produce results faster.

ANSYS APDLAbaqus PythonOpenFOAMBatch & HPC
Mid-sized project · fixed sprint budget

Pre- and post-processing tooling, web portals, SaaS CAE

Mesh generators, geometry importers, visualisation dashboards in Three.js or via VTK/ParaView, and cloud-native portals that let non-engineers kick off a simulation without first learning Abaqus. Often Python on the backend, a React or Astro frontend, and an integration with a Kubernetes cluster for the heavy runs.

Mesh generationThree.js / VTKCloud HPCWeb portal
Larger project · fixed sprint budget

Custom solvers in C++, Fortran or CUDA

When no vendor package covers what you want to simulate: a custom Finite Element solver with deal.II or MFEM, a specialist CEM solver, acoustic scattering, plasma physics. C++ or Fortran at the core, MPI for parallel computing, CUDA or OpenCL for GPU acceleration, and Python wrappers for scripting. A project of several sprints with close involvement from your own researchers.

deal.II / MFEMCUDA / OpenCLMPILegacy Fortran

What you get at the end.

Production-ready CAE software plus everything you need to keep it running and develop it further yourself.

  • Working solver or tooling codebaseC++, Fortran or Python codebase with a build system (CMake), unit tests, verification cases and benchmark suites against analytical solutions or existing packages.
  • HPC or GPU deploymentRunning on your on-prem cluster, AWS ParallelCluster, Azure CycleCloud or Google Cloud HPC. SLURM or PBS job scripts, container images and monitoring.
  • Pre- and post-processingMesh import from Gmsh, NetGen or CAD formats; visualisation via VTK, ParaView or a custom Three.js viewer; export to CSV, HDF5 or CGNS for further processing.
  • Documentation and theory manualAPI documentation, a user guide and, for custom solvers, a theory manual covering the equations used, the discretisation and the validation results. Indispensable for peer review and audits.
  • Knowledge transfer to your R&D teamPair-coding sessions, a codebase review, and clear agreements on who is responsible for further development after delivery.
  • Maintenance contract (optional)Bug fixes, dependency updates and further development at a fixed sprint capacity. For solvers running in production, some form of long-term support is almost always needed.

Which teams and sectors we build for.

CAE work shows up in many sectors, each with its own emphasis. The common denominator: a team that already has deep domain knowledge, is hitting the limits of a commercial package somewhere, and wants its own software to make the difference in its product or service.

Manufacturing and engineering firms. Machine building, automotive, aerospace. Classic FEA for stiffness, fatigue and crash; CFD for cooling, aerodynamics or internal flow; multibody dynamics for mechanisms. This often means scripting around ANSYS or Abaqus to take repetitive work out of the design process, or a custom tool that calculates parametric variants without an engineer having to set up the simulation again by hand each time.

Energy. Wind, transformers, high voltage, nuclear. Here we often see coupled problems (electromagnetic simulation alongside thermal and mechanical behaviour) and strict validation requirements from certification. Custom solvers or package wrappers are rarely delivered here without peer review.

Biomedical. Implants, prostheses, medical instruments. FEA for stress in materials, CFD for blood flow, acoustic simulation for hearing solutions. An important nuance: software that performs patient-specific calculations often falls under the MDR/IVDR, which places additional demands on documentation, validation and risk analysis.

Defence. Ballistics, EM shielding, antenna design, radar cross-section. Sensitive work that often has to run on-prem, with security-cleared engineers and strict export-control rules. We work here on an on-call basis, in close collaboration with your own security team.

Construction. Structural analysis for buildings and infrastructure, often linked to BIM models. This is where CAE and architectural informatics meet, for example automatic export from Revit or IFC to an FEA pre-processor.

Universities and research institutes. PhD research, TKI and EU projects. There is usually deep physics knowledge here but little capacity for software engineering. We bring in build systems, tests, CI/CD, parallel computing and code review; the researchers keep the physics in their own hands.

Software vendors. Companies that bring their own simulation package to market and are looking for extra capacity, whether for the solver core, the UI or cloud deployment.

Tech stack we often use.

There is no fixed blueprint. We choose per project, in consultation with your researchers, based on what suits the physics and your existing infrastructure. The combinations below come up most often.

Solver core. C++ with Eigen for linear algebra, deal.II or MFEM for finite element discretisation, OpenFOAM as a starting point for CFD, and FEniCS where Python productivity is wanted. For legacy integration or heavy numerical kernels, Fortran 90/2008, often combined with BLAS/LAPACK implementations.

Parallel computing. MPI for distributed memory, OpenMP for shared memory, and hybrid combinations on modern clusters. PETSc and Trilinos where we need sparse linear algebra at large scale.

GPU acceleration. CUDA for NVIDIA, OpenCL or SYCL for portable code. Kokkos or RAJA when we want to stay performance-portable across CPU and GPU targets. Profiling with NSight or nvprof, because naïve porting rarely delivers the gains you expect.

Mesh generation. Gmsh for scriptable mesh building, NetGen for tetrahedral meshes, CGAL for robust geometric operations. Sometimes a custom mesher when the standard tools cannot handle the geometry.

Visualisation. VTK and ParaView for scientific visualisation, Three.js or regl for web portals, and matplotlib for reports. For large datasets, streaming via VTK-XML or bulk handling via HDF5/CGNS, rather than loading everything into memory.

Cloud HPC. AWS ParallelCluster, Azure CycleCloud, Google Cloud HPC. SLURM or PBS Pro for job scheduling, Singularity or Apptainer for reproducible runs on shared clusters. Spot instances to keep costs down wherever the workload can handle checkpoint-restart.

Scripting and orchestration. Python across the board: for pre- and post-processing, for batch orchestration, for calling ANSYS APDL or the Abaqus Python API, and as a bindings layer on top of C++ kernels via pybind11.

AI-augmented simulation. Surrogate models with PyTorch or TensorFlow alongside a traditional solver, to sample parametric spaces cheaply. This works well where the physics can be learned, and it always goes hand in hand with validation against the real solver: not a replacement, but an accelerator.

Not sure about a large project yet?

Test your idea first: a working prototype in 1 day

With OneDayBuild, we make your idea tangible in a single day for €1,150, so you know whether further development is worth the investment. Decide to go ahead with the full build? Then we deduct the cost in full.

View OneDayBuild →

When custom CAE software is the right choice.

Four signals that prompt clients to get in touch. If you recognise one of them, we'd be happy to talk through the approach.

Standard package too limited

Your physics doesn't fit in ANSYS

Your research falls outside the standard physics of vendor packages: non-Newtonian flow, coupled multiphysics, plasma, or a sector-specific variant of Maxwell's equations that you have validated yourself.

Repetitive work

Engineers keep redoing the same work

On every project your team runs the same Abaqus setup with different parameters, or someone manually builds the same mesh in Gmsh. Scripting and automation give them that time back for the real engineering work.

Wider accessibility

Non-engineers want to simulate

Sales, design or customers would like to run parametric variants without a vendor licence or a week of training. A web portal with a simplified frontend on top of your solver solves that.

Performance limit

Runs take too long

Your simulations need GPU acceleration, better parallel decomposition or a cloud burst to hundreds of cores. More often than not, that is a software engineering problem rather than a case for more hardware.

How a CAE project works.

1

Introduction and technical scoping

A conversation with your R&D or engineering lead. We map out the physics, the vendor packages, the HPC environment and the validation requirements involved. Often with one of our C++/Fortran engineers joining.

2

Proof of concept

A short phase in which we validate the riskiest assumption, for example: can we run this solver on a GPU, or do our results match a reference case in ANSYS? Only then do you commit to the wider project.

3

Building in sprints

Two-week cycles with working releases, accompanying verification cases and ongoing code review with your researchers. Performance profiling and parallel scaling early in the project, not just at the end.

4

Validation and delivery

Verification against analytical solutions, validation against existing packages or measurement data, and a traceability report for regulated industries. Then knowledge transfer and, if you wish, an ongoing maintenance track for patches and extensions.

Frequently asked questions.

What clients in engineering and R&D teams typically ask us before we begin.

Will you replace ANSYS, Abaqus or OpenFOAM in our organisation?
No. For mainstream FEA and CFD, those packages are better than any custom solution that can be built within a reasonable budget. We complement them: scripting around them, custom solvers for physics the package does not cover, or an accessible web front end on top of existing runs.
Why do you choose C++ or Fortran rather than Python for solvers?
Python is excellent as an orchestration layer, for scripting, and for pre- and post-processing. For a solver's computational core, where the same loop runs billions of times, we almost always choose C++ (Eigen, deal.II, MFEM) or, where needed, Fortran for legacy integration. We often combine the two: a C++ core with Python bindings via pybind11.
Can you handle electromagnetic simulation or other specialist physics?
Yes, provided we organise the collaboration properly. For CEM, acoustic scattering, plasma or multiphysics integrations, we always work together with your domain experts. We bring the software engineering, parallel computing and validation infrastructure; your researchers bring the physics and the reference data.
What about GPU acceleration via CUDA?
For some solvers, GPUs deliver orders of magnitude in speed-up, but not for everything. A sparse direct solver simply performs worse on a GPU than an iterative method or a stencil computation. We measure first, before we port — that saves a lot of wasted effort.
Can you write scripts for ANSYS APDL or the Abaqus Python API?
Yes, this is one of the most commonly requested options. We build automation pipelines that set up parametric studies, extract results and link them to your PLM or issue tracker. The heaviest computation keeps running in ANSYS or Abaqus — we build the workflow around it.
What determines the cost of a CAE project?
The biggest factors are: how much new work there is versus wrappers around existing tooling, whether a custom solver needs to be built, how much validation and peer review your sector requires, and how deeply we integrate with your HPC cluster or cloud. We work with fixed sprint budgets, so you can also adjust or stop the project at an early stage.
Do you work with universities or research institutes?
Yes, regularly. Many CAE projects rely on doctoral research or a TKI/EU grant. We are comfortable with co-development, can work within open-source licence requirements (LGPL, GPL), and deliver publication-ready validation reports where needed.
How long until we see results?
A scripting or automation job often delivers visible time savings for the engineering team within just a few sprints. A custom solver built from scratch is by definition a multi-sprint effort with intensive verification work. We always start with a proof of concept to validate the riskiest assumption early.
How do you handle intellectual property and publication rights?
By default, the IP of the work we write belongs to you. For co-development with universities or research institutes, we agree together on what may be published and what stays under NDA, and we respect the licences of open-source components such as deal.II (LGPL) or OpenFOAM (GPL). For sensitive defence or medical work, we operate under strict confidentiality and export-control agreements.
Can this be linked to our existing PLM, CAD or test environment?
Almost always. We integrate with Teamcenter, Windchill and 3DEXPERIENCE for PLM, import CAD geometry via STEP, IGES or native formats where needed, and link test data from measurement environments via standard formats or REST APIs. The integration layer is usually Python; for heavier data streams we use HDF5 or CGNS for exchange.

Talk to us about your CAE challenge.

A no-obligation introductory call of half an hour. We listen to the physics, the packages you already use and what you want to achieve. We are honest about what we can and cannot build for you; sometimes the answer is a better licence, not a custom codebase.

Edit content