About DSFE

The Dynamic Systems Framework Engine (DSFE) is a final year Computer Science project developed to support the exploration and analysis of numerical integration methods under varying dynamic conditions.

Although physically grounded, DSFE prioritises numerical-transparency first, and visualisation second. The framework is designed for researching mathematic models through controlled numerical simulations, producing reproducible amd quantitative output data while remaining consistent with physically-valid system and enivronment parameters.

DSFE integrates real-time visualisation using OpenGL, GLSL, GLM, and ImGui to introduce interpretable representations of system behaviour. The visual layer is an addition with the intention of complementing, not replacing, the underlying numerical analysis.

The framework also includes the Dynamic Systems Language (DSL), a domain-specific scripting langauge that enables exact experiment reproduction, parameter control, and determinisitic test execution - one of the biggest reasons for adding DSL.

As an independant an extensible final year project, DSFE allows users to:

• Define custom dynamic systems
• Import external models
• Design their own DSL scripts
• Build their own experimental regimes
• Run in either batch or GUI mode
• Run parallel instances without file restrictions

This open architecture intentionally avoids hidden "Black-Box" abstractions, and instead favours transparency, reproducibility, and research flexibility.

Disclaimer:
The DSFE software has been developed, released, and maintained soley by me(@SaltyJoss).
If you identify any significant bugs, logical inconsistencies, implementation errors, or any citation issues, please open an Issue or contact me directly via GitHub.
Constructive feedback and technical corrections are welcomed, as they contribute to improving both the software and my understanding of the subject matter.

Project Motivation:

While DSFE originated as a final-year project, it reflects a sustained interest in computational mathematics, computational physics, and their application to space-oriented dynamical systems.
I hope that this repository will continue to evolve as the underlying numerical methods, modelling strategies, and experimental frameworks are refined and extended. This project forms part of a broader and continuing exploration into how mathematical models govern the behaviour of physically motivated dynamical simulation environments.

Installation

Pre-Requisites:

Before donwloading the latest release, you will need to have installed the following:

• Latest Visual C++ Redistributable
  

DSFE Installation:

Download the latest release of DSFE from Release in the DSFE GitHub Repository:

• Latest Release of DSFE
  

Running DSFE

As an executable

Download and extract the files from the latest release of DSFE and run the executable (Engine.exe on Windows) as you would any other binary!

Batch mode (CLI)

Open a terminal in the extracted release folder and run the engine in --batch mode to execute a DSL script that automates simulation sweeps.

# Show help / usage
PS C:\Users\SaltyJoss\dsfe-v0.7.1r-alpha-windows-x64> .\Engine.exe -h

# Example: one of the commands used to run my tests:
PS C:\Users\SaltyJoss\dsfe-v0.7.1r-alpha-windows-x64> .\Engine.exe --batch -t assets/DSLScripts/vispa_report_test_1.dsl --name vispa_rA_t1 --basedt 1/960 --baseint rk4 --dt 1/30,1/60,1/120,1/240,1/480 --int euler,midpoint,heun,ralston,rk4,rk45

Project Info

Languages used

Robotic Models used in DSFE:

• Google Deepmind's open source models (MuJoCo) of Z1, UR5e, iiwa14, Panda, and H1 robotic systems
• StanforASL's repo for Panda robotic arm
• Unitree Robotics's repo for the Z1 and UR5e robotic arms
• Airbus's repo for the their Versatile In-Space and Planetary Arm (VISPA) URDF and model files

Roadmap Ideas:

IMPORTANT:
As of Release v0.7.1r-alpha, I will be focusing on my dissertation for this project and coursework for my other modules, as I am finishing my degree.
Therefore, I most likely will not make any updates until that period is over.

Todo List:

• Implement collision meshes with existin dynamics pipeline
• Improve UI, making it Research-Oriented
• Add workspace layouts
• Support multiple concurrent sessions
• Move simulation data output to a dedicated Data-specific thread (IMPORTANT)
• Replace the current diagonal model with the standarised full-matrix rigid-body model
• Support multiple articulated systems within a single simulation instance
• Extend DSFE to support other classes of dynamical systems outside robotic manipulators
• Further extend physcial modelling for different robot models (humanoid, legged)
• Seperate physics/mathematics core from the GUI and visualisation layers
• Explore migration to a CMake-only build system
• Explore DX11 and Vulkan alternatives
• Get DSFE to work on Linux
• Explore non-x64 systesm support
• Explore the adoption of standardised URDF XML in place of the current DSFE json format
• Implement unit tests for each method relevant to numerical analysis
• Implement solution to current friction model (Seems to be introducing stiffness into RK4/RK45?) - LPV or Karnopp approach maybe?
• Need to look at using CRBA instead of just looping through a mass matrix loop

Citations

If you use this software in academic work or any published research, please cite it.
See CITATION.cff.

License

Licensed under the GPL-3.0 License.

TL;DR:
This project is licensed under GPL-3.0. You may use, modify, and distribute it (including commercially).
If you distribute this project or a modified version, you must provide the corresponding source code under GPL-3.0, and keep copyright, license, and attribution notices intact.
Modified versions should be clearly marked as modified. See the LICENSE file for details.

Attribution: Please retain the original author credit. A link back to this repository is greatly appreciated.

Third-Party Tools Used:

The software itself is made of 3 seperate solutions that are under the GPL-3.0 License. However, it has been built and tested using various thirdparty tools and libraries.

• Eigen for high-performance linear algebra operations that compute robot kinematics, dynamics, and numerical integration
• GLM for OpenGL-compatible vector and matrix types for graphics transforms, camera math, and rendering-side calculations
• GLFW for creating windows, manage OpenGL contexts, and handle user input across platforms
• GLAD for loading OpenGL function pointers at runtime, and enabling access to more modern OpenGL features
• ImGui for immediate-mode GUI for runtime controls, debugging panels, simulation visualisation tools, and the DSL script editor
• ImPlot for more complex realtime plots used during simulation runs in DSFE
• Assimp for importing 3D meshes and scene data from many file formats for robot models and misc objects
• nlohmann Json for integration of .json files within c++, allowing robots to have defined properties that can be easily retrieved upon loading
• HDF5 for storing structured time-series data from robotic arm simulation runs for post-analysis and comparisons of integration methods performance and stability
• stb image for lightweight loading of png and jpgs files previously used in cubemaps
• SSAO logic was taken and derived from SemiWaker's SSAO repo - please remember this for any logic SSAO-related.

(back to top)

Other Disclaimers:

AI Usage Disclaimer:
AI tool were used in limited and defined ways throughout this project:

• Assisstance in finalising PBR and IBL GLSL shader implementations
• Debugging support after my own attempts using logical analysis, documentation, academic references, and technical forums
• Early-stage resource discovery and outline (e.g. helping identify relevant literature and refine search queries)

Outside of the GLSL shader implementations, any AI-assisted output was limited to implementation guidance and debugging suggestions. All such suggestions were ritically evaluated and verified prior to usage, with any fixes being developed and implemented by myself.