{"block_close_oss.c33fd1fe9c":"Community and ecosystem","core-extras.96d330537a":"Base IR","core-extras.bee831a169":"Substrate","core-extras.61a0822826":"Apps on Core","core-extras.15438cc098":"not supported","core-extras.ad565d9d01":"Feature","core-extras.0155bf03e5":"Segment legend","core-extras.8b7110078e":"Algorithm groups by data type","core-extras.25ab4276a6":"Scrollable capability matrix","open-source-fmi.dd1af329dd":"Dweve FMI addresses platform drift in simulation. Fixed-point profiles and backend checks make differences visible before they reach a safety case.","open-source-fmi.a010de5c61":"Fabric","open-source-fmi.fe0a091fdb":"Products","open-source-fmi.ceb3e3fe8c":"Fixed-point arithmetic library powering FMI determinism.","open-source-fmi.cd84197771":"Numerus","open-source-fmi.6cc3364a24":"Deterministic simulation","open-source-fmi.9965ac0ca6":"Deterministic binary retrieval engine.","open-source-fmi.c91597c8b9":"BitWeave","open-source-fmi.dbd4513784":"Cryptographic proof infrastructure for AI reasoning.","open-source-fmi.df84637182":"AION","open-source-fmi.d5d6e83bf2":"Continue exploring","open-source-fmi.75e393a1ac":"Explore related systems","open-source-fmi.f9743247fa":"Read the documentation","open-source-fmi.db52af1cb6":"Run the example","open-source-fmi.f8592057ea":"Run the damped oscillator on two supported targets and compare the outputs. Reference checks expose any divergence before it enters a safety case.","open-source-fmi.cda2544237":"Deterministic simulation, verified","open-source-fmi.90e40d5043":"Get started","open-source-fmi.fd615fc047":"FMI","open-source-fmi.650fabe787":"Deterministic simulation","open-source-fmi.24a86715d8":"FMI / DETERMINISTIC SIMULATION","open-source-fmi.f1987bc2d1":"Validation","open-source-fmi.d671ccad33":"MPFR-backed reference checks","open-source-fmi.62b90e42bb":"result contract / MPFR oracle","open-source-fmi.a9e552d7cb":"Proof infrastructure","open-source-fmi.732356da40":"Deterministic retrieval","open-source-fmi.f7b620280c":"Fixed-point arithmetic","open-source-fmi.4d51b77a8e":"Replay contract","open-source-fmi.362f1f0eaa":"Compared across all three","open-source-fmi.d857fe164f":"Not a supplier","open-source-fmi.266a9a0b8f":"You decide","open-source-fmi.1011dfa597":"The default, not an upgrade","open-source-fmi.e03947cc0c":"Sovereignty","open-source-fmi.a64165efd9":"No special machine needed","open-source-fmi.08a557101e":"Your hardware","open-source-fmi.ab65f2797e":"Inside a border you choose","open-source-fmi.980c5d4a9d":"EU region","open-source-fmi.8c0f01c721":"On your own machines","open-source-fmi.499493296b":"On premise","open-source-fmi.b67953af9e":"One platform, your choice","open-source-fmi.d5a9f6f81a":"Three postures","open-source-fmi.d0158524ed":"YOUR HARDWARE","open-source-fmi.c387fd0cd2":"EU REGION","open-source-fmi.766e2cad1e":"ON PREMISE","open-source-fmi.cfa4a51372":"Two questions decide procurement: where does it run, and who controls the evidence. Dweve FMI runs on hardware you already own, on premise or in a European region, while the model and validation record stay inside a boundary you choose.","open-source-fmi.3cd2aa3cc1":"and on your own ground","open-source-fmi.b144a95356":"European,","open-source-fmi.1d197d39c5":"Where it runs","open-source-fmi.65a4906fa4":"Clean exit","open-source-fmi.867ec601c1":"Evidence to inspect","open-source-fmi.776c33d68b":"Model and evidence remain yours","open-source-fmi.4ea9899cee":"Exit path","open-source-fmi.6482c1822a":"Run the example, compare results","open-source-fmi.84a17118f2":"The claim","open-source-fmi.ef912c1e0b":"Read the validation record","open-source-fmi.32e3ee7a8f":"Validation record","open-source-fmi.efcd9f6f7e":"MPFR-backed checks","open-source-fmi.fef8e889dc":"Arithmetic evidence","open-source-fmi.301dd34439":"Before adoption","open-source-fmi.bc69d2355f":"What the evidence covers","open-source-fmi.9f217b9668":"RUN THE EXAMPLE","open-source-fmi.424af035ed":"VALIDATION RECORD","open-source-fmi.b6a9e5eec6":"TARGET MATRIX","open-source-fmi.aa72d4e11d":"VERIFY DIRECTLY","open-source-fmi.3c9725f7c9":"A safety claim needs more than a promise. Review the result contract, the supported-target matrix and the MPFR-backed validation method; then run the same example on two machines and compare the output before choosing where FMI belongs.","open-source-fmi.11f963abcc":"before adoption","open-source-fmi.ae52785e9a":"Read the evidence","open-source-fmi.69d819fce4":"Validation record","open-source-fmi.0f40aa19af":"More control","open-source-fmi.93ab03ffed":"Less spent twice","open-source-fmi.c56bf4b456":"No single supplier to depend on","open-source-fmi.7907ede934":"De-risks","open-source-fmi.62c436123e":"Runs on hardware you own","open-source-fmi.63a4b530e5":"No time lost reconciling results","open-source-fmi.6a29f08e06":"Saves","open-source-fmi.a71897888d":"One declared safety record","open-source-fmi.2b89699f87":"Where the value lands","open-source-fmi.8c336ff3db":"The outcome","open-source-fmi.3115880727":"CLEAN EXIT","open-source-fmi.5465bada04":"OWN HARDWARE","open-source-fmi.e6b9493f79":"NO RECONCILING","open-source-fmi.109049bb62":"ONE DECLARED RECORD","open-source-fmi.bf2dd21274":"The reason to care is operational, not technical. By comparing the same simulation under one declared contract on each machine, you see where a target differs before you close the safety case. Teams no longer have to reconcile differences silently. The work runs on the hardware you already own, and a move to new kit gets an explicit validation path.","open-source-fmi.ce5b13e336":"Run it anywhere","open-source-fmi.b2a38e7a9e":"Prove it once","open-source-fmi.6f696724c6":"What it saves and de-risks","open-source-fmi.65a198410c":"Removed here","open-source-fmi.10867d2df5":"Paid repeatedly","open-source-fmi.914362cebb":"One vendor, one roadmap, one price you do not set.","open-source-fmi.bf5dde2d06":"Supplier dependency","open-source-fmi.23db4ac1b2":"A new chip or region restarts validation across the portfolio.","open-source-fmi.b042fec0cc":"New hardware","open-source-fmi.c9c0341915":"lost time","open-source-fmi.33d7738484":"Teams argue over whose machine produced the right result.","open-source-fmi.8c902e8583":"Reconciling","open-source-fmi.9792b9b264":"N cases","open-source-fmi.220baaade0":"Each platform needs its own safety case because numbers can differ.","open-source-fmi.3e33105b1b":"Re-validation","open-source-fmi.6be178f88e":"Where cost hides","open-source-fmi.ab7280b5af":"THE OLD WAY","open-source-fmi.1fc9bd9c82":"NO RE-VALIDATION","open-source-fmi.973f781c07":"The case for switching is easiest to see laid out as a comparison. On one side, simulation that varies per platform: a safety case re-validated for every machine, teams reconciling numbers that should already match, and a re-validation every time the hardware changes. On the other, results compared under one declared contract, so the evidence shows where a deployment differs. The difference is operational, not technical.","open-source-fmi.6a08b3b5c3":"side by side","open-source-fmi.4012f9d45f":"Same work,","open-source-fmi.4690546dd0":"The old way, and this","open-source-fmi.3751d8a6a8":"Run on your hardware","open-source-fmi.2e67859212":"Prove once","open-source-fmi.6af74613cf":"Built in Europe","open-source-fmi.44ab85a252":"Origin","open-source-fmi.327bdc843a":"Remove the runtime; model and evidence remain","open-source-fmi.a148b36c17":"One reusable safety record","open-source-fmi.fdb4974dbe":"Validation scope","open-source-fmi.01cb445dea":"Workstation · cluster · FPGA · edge","open-source-fmi.3123868410":"Deployment range","open-source-fmi.3915907107":"Cross-target comparison","open-source-fmi.3229609e15":"Result contract","open-source-fmi.f988d88a5f":"The operating facts","open-source-fmi.fca77b7e3a":"One model, compared across targets","open-source-fmi.5b116da2ea":"ONE DECLARED RECORD","open-source-fmi.c968638a6e":"DETERMINISTIC","open-source-fmi.7e00f3d142":"A simulation model should make any hardware-dependent difference visible. Dweve FMI defines one result contract across supported targets, checks each backend against an MPFR oracle and lets one validation record travel with the model.","open-source-fmi.224da689ba":"every target is compared","open-source-fmi.3d1e7bdec2":"One model","open-source-fmi.f7dd5c66e9":"The operating contract","open-source-fmi.4fcf346811":"Just the benefit","open-source-fmi.0b049b5346":"Nothing to do","open-source-fmi.b258b25d07":"The result follows the declared contract","open-source-fmi.ac09b9600c":"Trust it","open-source-fmi.1c2d25f042":"Designed and tested in Europe","open-source-fmi.e6ad44f1ed":"Where from","open-source-fmi.8219743477":"No, engineers run it in the background","open-source-fmi.6cb165ad18":"Do I need to manage it","open-source-fmi.425d5db31c":"No, it works on its own","open-source-fmi.9e135ce84f":"Understand it","open-source-fmi.e3229cf237":"The questions people ask","open-source-fmi.a12a815f9b":"Peace of mind","open-source-fmi.4a4841a6f1":"NO WORRY","open-source-fmi.bd4e9c0810":"NO SETUP","open-source-fmi.b1f071a446":"NO EXTRA TASK","open-source-fmi.abc0fdccb9":"It is fair to wonder whether something like this is for you to deal with. It is not. Engineers run it in the background, where it compares safety simulations across machines and makes differences visible.","open-source-fmi.c878874ffa":"Someone else does the work","open-source-fmi.37a0b494b7":"You get the benefit","open-source-fmi.8a61881223":"Set your mind at ease","open-source-fmi.72cd39d7f8":"For all of us","open-source-fmi.dd6c938563":"Plain good","open-source-fmi.eeb22aec83":"Runs on ordinary computers","open-source-fmi.de72ea9e60":"Simple","open-source-fmi.c32396901c":"One validation record follows the model","open-source-fmi.75f527181b":"Reusable safety case","open-source-fmi.02bf32494a":"MPFR-backed checks catch divergence before use","open-source-fmi.cf9b77061f":"Drift caught","open-source-fmi.34e5fa45f5":"A declared result contract","open-source-fmi.72aee27620":"Reliable","open-source-fmi.f603c0224f":"In everyday terms","open-source-fmi.ccb9f1391c":"Four reasons","open-source-fmi.b6c0c395ff":"ON ORDINARY COMPUTERS","open-source-fmi.4a9768fab0":"NO SETUP","open-source-fmi.33906a7dfd":"DECLARED RESULT","open-source-fmi.b00a146670":"DECLARED RESULT","open-source-fmi.8ab073271f":"You do not have to understand how it works to enjoy what it does. Think of it like clean water or good roads. You never see the work, but your day is better because someone did it well. Here are four plain reasons it matters.","open-source-fmi.ebd2e15492":"behind safer machines","open-source-fmi.b0b9c6048d":"A quiet helper","open-source-fmi.39b28767ec":"Why it is good for everyone","open-source-fmi.3477f4d91d":"Declared result","open-source-fmi.f28da4b59f":"Comparable test","open-source-fmi.d0df7ff719":"The result can be trusted","open-source-fmi.584c2f9e49":"Why it helps","open-source-fmi.02b2cf4e02":"They can be compared","open-source-fmi.e0d1dc9c8a":"With this","open-source-fmi.0a44b81281":"Results compared on both","open-source-fmi.83588406b9":"The goal","open-source-fmi.e13afd9f47":"A desk and a safety office","open-source-fmi.65be829a4f":"Two computers","open-source-fmi.3503011eec":"What you are looking at","open-source-fmi.704869f20f":"In plain words","open-source-fmi.660f3e8b3e":"NOTHING TO DO","open-source-fmi.a612bb3f40":"EVERY COMPUTER","open-source-fmi.ea4c48ae0c":"Here is the heart of it, shown simply. The same safety test runs on two different computers. On ordinary computers the two answers can come out a tiny bit different. With this, the comparison makes any difference visible. Flip the switch and watch what changes. That comparison is the whole point.","open-source-fmi.39d31d23af":"one comparison","open-source-fmi.e6a18ff62a":"Two computers,","open-source-fmi.516bf417a6":"The whole idea, in a picture","open-source-fmi.2f2b74b572":"Everywhere","open-source-fmi.8f5705be47":"The comparable test","open-source-fmi.12a67456b8":"Robots that work safely next to people.","open-source-fmi.2940ff1e5f":"Machines","open-source-fmi.338cd9b82b":"Steady power, tested before it is installed.","open-source-fmi.ff7126ef3f":"The grid","open-source-fmi.edf863d2b5":"Checked carefully before they reach a patient.","open-source-fmi.a8bdd2218d":"Medical pumps","open-source-fmi.7bb7da4026":"Tested thousands of times on a computer first.","open-source-fmi.675ae2cbaf":"Brakes and engines","open-source-fmi.1c72c0b962":"Tested before they are built","open-source-fmi.b1e737e76e":"EVERYDAY THINGS","open-source-fmi.5d9d34b03b":"FACTORIES","open-source-fmi.c2b6b521a7":"POWER","open-source-fmi.ea898684f8":"HOSPITALS","open-source-fmi.c6a8ab2f7b":"CARS","open-source-fmi.fca0f45bb6":"You will never use this, but you use the things it helps protect every day. A car, a medical pump, the power in your home, the machines in a factory. Each one is tested on a computer before it is built, and this is the part that makes differences between target platforms visible. Tap a picture to see why that matters for each one.","open-source-fmi.3c147615e8":"it quietly keeps safe","open-source-fmi.1cbefffe4b":"The everyday things","open-source-fmi.d69f76eab8":"Where it helps","open-source-fmi.0f7f1377f4":"Just the idea","open-source-fmi.1a03bcb291":"No jargon","open-source-fmi.3f66052a10":"From","open-source-fmi.35ca1675a9":"Built and tested in Europe","open-source-fmi.64ae43e8fe":"Assurance","open-source-fmi.3a21d9aab2":"Nothing to install or manage","open-source-fmi.7e13d94a5a":"For you","open-source-fmi.1fe023c72e":"Makes differences visible everywhere","open-source-fmi.b017742a89":"It does","open-source-fmi.6a12bacfff":"A careful helper for safety tests","open-source-fmi.3dd5d5b49f":"It is","open-source-fmi.c943a1db59":"If you only read one thing","open-source-fmi.cc835fe349":"The short answer","open-source-fmi.93844fe5e2":"FOR EVERYONE","open-source-fmi.04f52a5c28":"SAFE","open-source-fmi.1c34a90a63":"SIMPLE","open-source-fmi.642be3d898":"You will never use this yourself. But it is a small, careful thing that helps keep cars, planes, and medical machines safe. Here is the whole idea, one simple step at a time, with an everyday example for each one.","open-source-fmi.f572c73bb9":"and why it matters around you","open-source-fmi.66e1586456":"What is this,","open-source-fmi.a1be034bc8":"Replay comparison","open-source-fmi.5551c2393f":"Same FMU","open-source-fmi.a35c575f3d":"Hardware in the loop","open-source-fmi.7350eb1834":"FPGA shelter","open-source-fmi.572e251d1e":"Parameter sweep across nodes","open-source-fmi.d75dc68bbd":"Cluster","open-source-fmi.06ff03e32e":"Author and run, single host","open-source-fmi.9560ed3374":"Workstation","open-source-fmi.e57316ab69":"Three postures, one FMU","open-source-fmi.327a55f82d":"One FMU, every target","open-source-fmi.b503c4e427":"HIL","open-source-fmi.cef7f9bd36":"FPGA","open-source-fmi.e3b9b52696":"CLUSTER","open-source-fmi.7e785f79ba":"WORKSTATION","open-source-fmi.1edbc89e07":"A simulation engineer authors and runs an FMU on their workstation. The same FMU can be compared on a cluster for parameter sweeps. It can also be used on an FPGA shelter for hardware-in-the-loop scenarios where the latency budget is hard. The replay contract holds across all three.","open-source-fmi.1d9965564d":"Workstation, cluster, FPGA shelter","open-source-fmi.6ab2f5bf1f":"Same FMU","open-source-fmi.f4bbf42cfe":"Deployment topologies","open-source-fmi.6b5eb5323e":"Deterministic simulation","open-source-fmi.0c2a930099":"Profiles","open-source-fmi.b3776d63ad":"Backends","open-source-fmi.eb39bbf6cc":"Variance","open-source-fmi.51ab88da6e":"Reference check","open-source-fmi.217fc9a42f":"Deterministic simulation","open-source-fmi.fa407a656c":"Q31.32, Q16.16, Dec64_6","open-source-fmi.5fa265f0d4":"CPU, GPU, FPGA, edge, distributed","open-source-fmi.acc075b26e":"Checked against MPFR","open-source-fmi.e0c97bd053":"What ships","open-source-fmi.d6b54113f0":"Runtime profile","open-source-fmi.d59ed14bf9":"RUST","open-source-fmi.ca97162dc5":"Written in Rust on the Numerus arithmetic base, FMI uses fixed-point paths with MPFR reference checks and supports Model Exchange, Co-Simulation and Scheduled Execution across five backends.","open-source-fmi.c7afbc7eeb":"across every target","open-source-fmi.d42a2db3fe":"Verified","open-source-fmi.7b771909eb":"Checked","open-source-fmi.5ec02acc14":"Model unchanged","open-source-fmi.03128bed90":"Verification","open-source-fmi.a5b48d1757":"Unchanged, standard FMU","open-source-fmi.68c2cc7f0c":"Model","open-source-fmi.25169adeca":"One case, every backend","open-source-fmi.87025bab20":"Safety case","open-source-fmi.a2b55fb9da":"Float swapped for fixed-point","open-source-fmi.45f053dc73":"Arithmetic","open-source-fmi.5f6c5a53a3":"What changes, what does not","open-source-fmi.be6d2b407e":"Floor swapped","open-source-fmi.3691acaffc":"Traditional FMI can vary per platform because it sits on floating-point. Dweve FMI uses a fixed-point arithmetic path with MPFR reference checks. The simulation model and safety case remain explicit, while the same FMU archive can be compared across workstation, cluster and FPGA. The deployment choice is operational, not numerical.","open-source-fmi.6c1b1ae685":"Keep the model and the safety case","open-source-fmi.ea86596594":"Swap the floor","open-source-fmi.762dc3d3ad":"Float versus fixed","open-source-fmi.e2a924db5a":"No platform asterisk","open-source-fmi.5c0eaf74b2":"Reproducibility = trust","open-source-fmi.2dbb77a4db":"Chemical mass and energy, PLC co-sim.","open-source-fmi.3e6c37afa5":"Process automation","open-source-fmi.09572ad1cf":"Kinematics, trajectory, sensor fusion.","open-source-fmi.fa3cd523ba":"Control and planning","open-source-fmi.544a8a176d":"Power converters, renewables integration.","open-source-fmi.9fa6f76803":"Grid and power","open-source-fmi.aac5f8af78":"Pump dynamics and device behaviour.","open-source-fmi.eae25218d9":"Device performance","open-source-fmi.11a1136a89":"Control law validation, pilot in loop.","open-source-fmi.1959e1dc45":"Flight dynamics","open-source-fmi.a16f63ff79":"Engine, transmission, brake, suspension.","open-source-fmi.89341b9804":"Powertrain and chassis","open-source-fmi.78bd320e1a":"Where FMI lands","open-source-fmi.2e2486ec33":"SECTOR LADDER","open-source-fmi.0b19787d2a":"INDUSTRIAL","open-source-fmi.9147d23e40":"ROBOTICS","open-source-fmi.b3eb6065b2":"ENERGY","open-source-fmi.1731152693":"MED","open-source-fmi.7a32d61649":"AERO","open-source-fmi.50c3f10f5b":"AUTO","open-source-fmi.453490866d":"Dweve FMI serves domains where simulation results inform design and decisions. Automotive, aerospace, medical devices, energy, robotics, industrial control, and digital twins all need evidence that simulation outputs are reproducible, traceable and controllable per target platform.","open-source-fmi.c12778212a":"is non-negotiable","open-source-fmi.c84c8684f9":"Where reproducibility","open-source-fmi.486fb84c09":"Primary domains","open-source-fmi.9babbe6fed":"Deterministic simulation","open-source-fmi.b570316ceb":"Model exchange and co-simulation","open-source-fmi.79f5b225cf":"Modes","open-source-fmi.7ac03632f2":"Verified against MPFR","open-source-fmi.58c76110f0":"By the numbers","open-source-fmi.a729b3158a":"Round-trip fidelity","open-source-fmi.1d7c70637c":"Compliant import","open-source-fmi.8b7df3b421":"Correctly rounded fixed-point arithmetic","open-source-fmi.8ae897a240":"Deterministic kernel","open-source-fmi.38a040c337":"Dweve FMI","open-source-fmi.e4621247b0":"Twin event sourcing","open-source-fmi.34214aaa54":"Bridge","open-source-fmi.08ce9a6f83":"Multi-FMU master algorithm","open-source-fmi.a5e7607493":"Orchestrate","open-source-fmi.d72141b240":"Standard FMU archive, signed","open-source-fmi.f3e4fadb9e":"Export","open-source-fmi.8183c95776":"Any FMI 3.0 compliant tool","open-source-fmi.d6fbc9d2bd":"Import","open-source-fmi.d3ce50b819":"Where FMI plugs in","open-source-fmi.07a56cd0db":"INTEGRATION GRAPH","open-source-fmi.bec8a661ee":"BRIDGE","open-source-fmi.6d0ca17825":"ORCHESTRATE","open-source-fmi.c0b9641f51":"EXPORT","open-source-fmi.b034fe864d":"IMPORT","open-source-fmi.21dd4be136":"Dweve FMI integrates with existing toolchains through FMU import and export, multi-model orchestration, and digital twin bridging. Import FMUs from any FMI 3.0 compliant tool with automatic float to fixed conversion. Export FMUs for downstream tools that require floating-point.","open-source-fmi.bfd2c7daac":"orchestrate, and bridge","open-source-fmi.1d2ba9a35c":"Import, export,","open-source-fmi.899e5920ef":"Fits the FMI toolchain","open-source-fmi.14ffdb8c88":"Loud on failure","open-source-fmi.6f61768f7c":"MPFR oracle","open-source-fmi.d8fcb69192":"Tolerance exceeded stops the run with a typed error and the named equation.","open-source-fmi.7e129e0a64":"Failure modes","open-source-fmi.1cd2d08aad":"A recorded run reproduces from its event log through the Twin bridge.","open-source-fmi.c0f85d6679":"Replay","open-source-fmi.9f9921bd52":"Same FMU on CPU, GPU, FPGA and edge. Output vectors compared.","open-source-fmi.946b2a4159":"Cross-backend","open-source-fmi.f359d78fdc":"Fixed-point operations checked against an MPFR reference.","open-source-fmi.81fc07fd34":"Four check stages","open-source-fmi.8501b5781e":"VALIDATION PIPELINE","open-source-fmi.4e250b4fde":"REPLAY","open-source-fmi.9b2d3887e5":"MPFR","open-source-fmi.4614acbc6e":"Numerical checks use the Numerus arithmetic floor and an MPFR reference. Cross-backend comparison runs the same FMU on each target and records any output difference. Deterministic replay reconstructs a recorded run from its event log, and failure modes are loud rather than silent.","open-source-fmi.122d0041bb":"Compared across targets","open-source-fmi.09c96602f5":"MPFR oracle","open-source-fmi.d23f65d234":"Validation harness","open-source-fmi.390bfe8641":"Same kernel","open-source-fmi.5ac19e0bce":"Across nodes","open-source-fmi.bb3d98dfee":"Distributed","open-source-fmi.54504b104b":"Embedded controllers","open-source-fmi.8440b9eb7d":"Edge","open-source-fmi.94ff919f31":"Hardware in loop","open-source-fmi.a7a987d710":"Parameter sweeps","open-source-fmi.a6a6318544":"GPU","open-source-fmi.4afb811042":"Workstation and CI","open-source-fmi.ff221d4752":"CPU","open-source-fmi.59080f06ce":"One kernel, five targets","open-source-fmi.7c698127c7":"Backend roster","open-source-fmi.a5c1c58f0e":"DISTRIBUTED","open-source-fmi.fe79447bad":"EDGE","open-source-fmi.50e2826c52":"The same deterministic kernel runs on workstation CPU, GPU, FPGA hardware, an embedded edge device and distributed nodes. Results can be compared under the declared contract, so the deployment choice is operational, not numerical.","open-source-fmi.a8d257247f":"every target","open-source-fmi.354db4a965":"Same simulation,","open-source-fmi.fbf68005eb":"Reference variance","open-source-fmi.0d95fab48e":"MPFR ground truth, used for verification only.","open-source-fmi.db1c784524":"Reference","open-source-fmi.2f01132c9b":"EXACT","open-source-fmi.2232deb06c":"6 dec digits, banking and billing scenarios.","open-source-fmi.362d711f93":"Decimal accounting","open-source-fmi.7fdd34297b":"Dec64_6","open-source-fmi.f720a1212d":"32 frac bits, default profile, full precision.","open-source-fmi.0d4863fc9a":"General simulation","open-source-fmi.378401cce4":"16 frac bits, narrow ranges, battery friendly.","open-source-fmi.8ff03fbc23":"Edge and embedded","open-source-fmi.1b9c6ea9c1":"Three deterministic profiles","open-source-fmi.b28817bbc6":"PRECISION LADDER","open-source-fmi.6e411e56f3":"Q31.32 covers most simulation needs. Q16.16 fits embedded and edge targets. Dec64_6 covers domain-specific decimal accounting. All three rest on the Numerus arithmetic base, where each operation is correctly rounded and verified against the MPFR mathematical reference library.","open-source-fmi.482fc6220f":"Reference comparison","open-source-fmi.b2d5f9e409":"Three fixed-point profiles","open-source-fmi.5bfbf7d800":"Cost is hidden","open-source-fmi.a197746040":"Variance is real","open-source-fmi.bc04491d9c":"New chip or cloud means re-validate the entire portfolio.","open-source-fmi.683c4d3deb":"Hardware lock-in","open-source-fmi.b0fcb6e7ff":"small numerical difference","open-source-fmi.25f191d4c0":"A trigonometric function in one library can differ slightly from another.","open-source-fmi.34dcf8850c":"libm variance","open-source-fmi.4b4d7f6128":"pin compiler","open-source-fmi.ee8b2d50ca":"Compiler optimisation changes float order; results shift.","open-source-fmi.ab090fdc37":"Compiler sensitivity","open-source-fmi.43b95f29db":"N test rigs","open-source-fmi.7e93753fef":"Workstation, CI, certification: compare the target platforms and record differences in the safety case.","open-source-fmi.2f9d0de86a":"Platform divergence","open-source-fmi.004862397c":"Four divergence sources","open-source-fmi.7e7ea34028":"WHERE FLOATS BITE","open-source-fmi.ef46602747":"LIBM","open-source-fmi.e0dbcded97":"COMPILER","open-source-fmi.4b35e752ed":"DIVERGE","open-source-fmi.20a8d961ed":"The Functional Mock-up Interface is the industry standard for model exchange and co-simulation. It is used in safety-critical domains where simulation results inform design decisions, safety cases, and regulatory submissions. Traditional FMI implementations often rely on IEEE 754 floating-point arithmetic, so platform differences need to be checked.","open-source-fmi.5eaf2787d4":"breaks compliance and trust","open-source-fmi.a74a9598b4":"Floating-point variance","open-source-fmi.8a9400005c":"The same simulation should not drift","open-source-fmi.4ec6d609ab":"Deterministic simulation","open-source-fmi.da59e25344":"Numerus, correctly rounded","open-source-fmi.ac152dffc1":"Arithmetic base","open-source-fmi.fbabe853f6":"CPU, GPU, FPGA, Edge, Distributed","open-source-fmi.6f46b8d91b":"Model Exchange, Co-Simulation","open-source-fmi.5528087839":"Verified facts about the project","open-source-fmi.60e6382282":"MODEL EXCHANGE","open-source-fmi.2dd1a09389":"Dweve FMI implements the FMI standard for Model Exchange, Co-Simulation and Scheduled Execution, built in Rust with deterministic fixed-point arithmetic. Real-valued computations follow the configured fixed-point path. Results can be compared across CPU, GPU, FPGA, edge and distributed targets, with MPFR used as a mathematical reference where applicable. Three fixed-point profiles cover engineering targets from embedded devices to GPU parameter sweeps without changing the simulation model.","open-source-fmi.a09604cfe3":"Fixed-point. Multi-backend","open-source-fmi.68f6f5a6f9":"Deterministic FMI","open-source-fmi.388d6fbc05":"What FMI is","open-source-fmi.72028daa5e":"The same FMU archive can be compared on each backend. One simulation, one validation record.","open-source-fmi.6fea20df53":"CHECK: output vectors compared with the reference","open-source-fmi.e55e620773":"verify cross-target parity","open-source-fmi.f403533333":"steps: 1000  backend: fpga  profile: Q16.16","open-source-fmi.f8e6f536dd":"run same FMU on FPGA backend","open-source-fmi.28654615e5":"steps: 1000  backend: cpu  profile: Q31.32","open-source-fmi.aff2418653":"run damped oscillator on CPU backend","open-source-fmi.720213ff23":"fmi: cross-platform determinism check","open-source-fmi.6c4b4eacce":"Same FMU archive","open-source-fmi.8df268baf0":"Same FMU, four backends","open-source-fmi.e4fa4ee240":"Cross-target check","open-source-fmi.d278e5fccc":"Run the damped oscillator reference model on your development machine and on your CI server. Compare the output vectors and retain the cross-platform validation record. The contract is the declared comparison and its scope, not an unqualified equality claim.","open-source-fmi.767a4d189a":"Every platform. Every run","open-source-fmi.da54c088ba":"Declared representation","open-source-fmi.131f781cb4":"The validation run","open-source-fmi.aba3dee917":"What it saves","open-source-fmi.ef3dffee30":"Built in Europe, data stays put","open-source-fmi.76b4d9f30d":"On premise, EU region, your hardware","open-source-fmi.14e290c0bf":"See the operating contract","open-source-fmi.db29d3b02a":"Dweve FMI is the standard exchange path for engineering teams that want to compare simulations across machines. Deterministic arithmetic makes the safety argument explicit per declared target instead of hiding platform differences. The work can run on hardware you already own or in a European region.","open-source-fmi.b72aa8825b":"on every target","open-source-fmi.c274b4ab67":" compare results","open-source-fmi.47e86cd0d8":"One simulation model","open-source-fmi.cc779305ae":"FMI","open-source-fmi.2f9ecc606a":"Safer cars, planes, and devices","open-source-fmi.750c2096f3":"Safety evidence should travel","open-source-fmi.21a1667b08":"Where is it from","open-source-fmi.7a3ea32828":"Yes, the result is checked","open-source-fmi.85083f1a43":"Can I look inside","open-source-fmi.2183315ae3":"Do I need to do anything","open-source-fmi.eb1b344997":"No, it works in the background","open-source-fmi.f4e4e83e14":"Do I manage it","open-source-fmi.2cc00136c2":"Engineers who build safe machines","open-source-fmi.54f8de57f6":"Who uses it","open-source-fmi.0970f40801":"Makes cross-target differences visible","open-source-fmi.ca032b5844":"Results compared across targets","open-source-fmi.7ccd8cfc31":"For everyone","open-source-fmi.afae86e6ff":"Deterministic simulation","open-source-fmi.faaeaea9b3":"Before a car, a plane, or a medical pump is built, engineers test it on a computer. The catch is that the same test can differ slightly between machines, and for a brake that tiny difference matters. FMI makes the comparison visible wherever the simulation runs, so the people checking safety know what they are comparing.","open-source-fmi.4f29c5fb6d":"for everyone","open-source-fmi.2f8c9bc1d6":" machines safe","open-source-fmi.84590e8809":"The quiet part that keeps","open-source-fmi.0b3bea0bdb":"Reference comparison against MPFR","open-source-fmi.2956ef9ad6":"Determinism","open-source-fmi.72d39472d8":"Fixed-point (Q31.32, Q16.16, Dec64_6)","open-source-fmi.05d5b4a2b6":"FMI, Model Exchange and Co-Simulation","open-source-fmi.2dfa66079d":"Standard","open-source-fmi.e9921e9ad2":"Rust (edition 2021)","open-source-fmi.89b86ab0e6":"Language","open-source-fmi.workspaceLabel":"Workspace","open-source-fmi.workspaceValue":"30 crates · runtime, tooling, and backends","open-source-fmi.942587e61e":"Project sheet","open-source-fmi.d4a74b503a":"Read the docs","open-source-fmi.acfc2cea44":"The current FMI workspace is more than an exchange boundary: it includes FMU import and export, an FMI 3.0 runtime and C FFI, co-simulation orchestration, solvers, TQL, conformance tooling, and CPU, GPU, FPGA, edge, and distributed backends. Fixed-point paths and MPFR-backed checks target reproducible results on supported targets.","open-source-fmi.0d9a1cecc7":"across supported targets","open-source-fmi.216ce8af87":"Reproducible simulations,","open-source-fmi.6ea56fae9e":"AUTO","open-source-fmi.1ebcf0170c":"AERO","open-source-fmi.0852bdaf94":"MED","open-source-fmi.7e8c74cbea":"ENERGY","open-source-fmi.98a8735785":"ROBOTICS","open-source-fmi.fde749e559":"INDUSTRIAL","open-source-fmi.ac76b931f7":"CARS","open-source-fmi.e5b73ae3b9":"HEALTH","open-source-fmi.10149aa571":"POWER","open-source-fmi.e0a6f4fda2":"FACTORY","open-source-fmi.5d0b2f6bd4":"OBSERVED","open-source-fmi.d3a933a34d":"MIXED","open-source-fmi.8766e017df":"VERIFIED","open-source-fmi.6e10953f3e":"PATH","open-source-fmi.35e0d0360a":"LIVE","open-source-fmi.10a87133a3":"SAFE","open-source-fmi.c341c7fe10":"BEFORE","open-source-fmi.hero.eyebrow":"FMI","open-source-fmi.hero.title.lead":"A co-simulation runtime in Rust","open-source-fmi.hero.title.accent":"that stays deterministic","open-source-fmi.hero.technical.lede":"FMI makes models interoperable. Dweve FMI is an FMI 3 co-simulation runtime in Rust: one model contract, solved deterministically, orchestrated across FMUs and placed on the backend you choose. Rust sits inside; the standard fmi3 function table remains at the boundary.","open-source-fmi.hero.technical.action.primary":"See the runtime contract","open-source-fmi.hero.technical.action.secondary":"Read the docs","open-source-fmi.hero.technical.ledger.label":"Project sheet","open-source-fmi.hero.technical.ledger.pill":"FMI 3","open-source-fmi.hero.technical.ledger.row.standard.label":"Standard","open-source-fmi.hero.technical.ledger.row.standard.value":"FMI 3: Model Exchange, Co-Simulation, Scheduled Execution","open-source-fmi.hero.technical.ledger.row.language.label":"Language","open-source-fmi.hero.technical.ledger.row.language.value":"Rust, with the complete fmi3 C ABI exported","open-source-fmi.hero.technical.ledger.row.numerics.label":"Numerics","open-source-fmi.hero.technical.ledger.row.numerics.value":"FMI floats at the boundary, deterministic Numerus formats inside","open-source-fmi.hero.technical.ledger.row.backends.label":"Backends","open-source-fmi.hero.technical.ledger.row.backends.value":"CPU, GPU, FPGA, edge, distributed","open-source-fmi.hero.technical.ledger.row.state.label":"State","open-source-fmi.hero.technical.ledger.row.state.value":"Checkpoint, restore, replay and branch","open-source-fmi.hero.technical.ledger.row.bridge.label":"Bridge","open-source-fmi.hero.technical.ledger.row.bridge.value":"Bidirectional Dweve Twin synchronisation","open-source-fmi.hero.technical.ledger.row.licence.label":"Licence","open-source-fmi.hero.technical.ledger.row.licence.value":"Apache-2.0 · self-hosted","open-source-fmi.hero.business.lede":"FMI, the Functional Mock-up Interface, makes simulation models interoperable. Dweve FMI is an open-source FMI 3 co-simulation runtime in Rust under Apache-2.0 that carries one model from the first design study into live operation beside the asset, without a rewrite at each stage.","open-source-fmi.hero.business.action.primary":"See the programme difference","open-source-fmi.hero.business.action.secondary":"Scale without a rewrite","open-source-fmi.hero.business.ledger.label":"Programme sheet","open-source-fmi.hero.business.ledger.pill":"FMI 3","open-source-fmi.hero.business.ledger.row.programme.label":"Programme","open-source-fmi.hero.business.ledger.row.programme.value":"One model from design to operation","open-source-fmi.hero.business.ledger.row.suppliers.label":"Suppliers","open-source-fmi.hero.business.ledger.row.suppliers.value":"FMI 3 packages validated at intake","open-source-fmi.hero.business.ledger.row.scale.label":"Scale","open-source-fmi.hero.business.ledger.row.scale.value":"Acceleration and distribution without a rewrite","open-source-fmi.hero.business.ledger.row.interruption.label":"Interruption","open-source-fmi.hero.business.ledger.row.interruption.value":"Costs the gap since the last checkpoint","open-source-fmi.hero.business.ledger.row.operation.label":"Operation","open-source-fmi.hero.business.ledger.row.operation.value":"Live Twin bridge with conflict policy","open-source-fmi.hero.business.ledger.row.record.label":"Record","open-source-fmi.hero.business.ledger.row.record.value":"Provenance for every value that crosses","open-source-fmi.hero.business.ledger.row.licence.label":"Licence","open-source-fmi.hero.business.ledger.row.licence.value":"Apache-2.0 · self-hosted","open-source-fmi.hero.consumer.lede":"FMI makes simulation models interoperable. Dweve FMI keeps the same model useful from the first test to operation beside the real machine: try a lift, pump or vehicle as a model before anything is built, then keep that model working alongside the machine.","open-source-fmi.hero.consumer.action.primary":"Start before the machine exists","open-source-fmi.hero.consumer.action.secondary":"The model beside the machine","open-source-fmi.hero.source":"Ask about the release","open-source-fmi.hero.consumer.ledger.label":"In plain words","open-source-fmi.hero.consumer.ledger.pill":"For everyone","open-source-fmi.hero.consumer.ledger.row.what.label":"What it is","open-source-fmi.hero.consumer.ledger.row.what.value":"A way to test machines as models first","open-source-fmi.hero.consumer.ledger.row.computers.label":"Computers","open-source-fmi.hero.consumer.ledger.row.computers.value":"The same model on small and large machines","open-source-fmi.hero.consumer.ledger.row.together.label":"Together","open-source-fmi.hero.consumer.ledger.row.together.value":"Separate models run as one system","open-source-fmi.hero.consumer.ledger.row.memory.label":"Memory","open-source-fmi.hero.consumer.ledger.row.memory.value":"Stop a test and continue it later","open-source-fmi.hero.consumer.ledger.row.beside.label":"Beside the machine","open-source-fmi.hero.consumer.ledger.row.beside.value":"Predictions next to real measurements","open-source-fmi.hero.consumer.ledger.row.open.label":"Repository","open-source-fmi.hero.consumer.ledger.row.open.value":"Publishes in round ten","open-source-fmi.breadcrumb.home":"Open Source","open-source-fmi.close.accent":"and keep it through every stage","open-source-fmi.close.panel.title":"What the contract fixes","open-source-fmi.close.panel.tag":"FMI 3","open-source-fmi.close.panel.row.0.label":"Interfaces","open-source-fmi.close.panel.row.0.value":"Three declared interface types","open-source-fmi.close.panel.row.1.label":"Identity","open-source-fmi.close.panel.row.1.value":"Values, clocks and state keep theirs","open-source-fmi.close.panel.row.2.label":"Checkpoints","open-source-fmi.close.panel.row.2.value":"Mode, time and solver state saved together","open-source-fmi.close.panel.row.3.label":"Placement","open-source-fmi.close.panel.row.3.value":"Nodes can change, the run does not","open-source-fmi.close.panel.foot":"Distribution changes where the work runs, not what the run means.","open-source-fmi.breadcrumb.current":"FMI","open-source-fmi.close.label":"Get started","open-source-fmi.close.headline":"Define the model once","open-source-fmi.close.body":"Dweve FMI publishes in the tenth round of the foundation release programme. Once it does, load the runtime through the standard FMI 3 function table your host already understands, or build with the Rust crates directly. Run your own model on your own hardware, checkpoint the study, and keep the same model beside the operating asset when it ships.","open-source-fmi.close.action.primary":"Read the FMI 3 standard","open-source-fmi.close.action.secondary":"Read the documentation","open-source-fmi.close.action.tertiary":"Explore related systems","open-source-fmi.next.eyebrow":"Continue exploring","open-source-fmi.next.aion.category":"Proof infrastructure","open-source-fmi.next.aion.title":"AION","open-source-fmi.next.aion.description":"Cryptographic proof infrastructure for AI reasoning.","open-source-fmi.next.bitweave.category":"Deterministic retrieval","open-source-fmi.next.bitweave.title":"BitWeave","open-source-fmi.next.bitweave.description":"Deterministic binary retrieval engine.","open-source-fmi.next.numerus.category":"Deterministic arithmetic","open-source-fmi.next.numerus.title":"Numerus","open-source-fmi.next.numerus.description":"The deterministic arithmetic that carries every Dweve FMI run inside the boundary.","open-source-fmi.next.fabric.category":"Products","open-source-fmi.next.fabric.title":"Fabric","open-source-fmi.next.fabric.description":"Durable execution for the workloads that outlive a single process.","open-source-fmi.section.fmi-eng-contract.eyebrow":"The standard as a runtime contract","open-source-fmi.section.fmi-eng-contract.headlineLead":"One model","open-source-fmi.section.fmi-eng-contract.headlineAccent":"driven three different ways","open-source-fmi.section.fmi-eng-contract.body":"Model Exchange, Co-Simulation and Scheduled Execution are three FMI 3 interface types, not three unrelated products. A host uses whichever interface types an FMU declares. Dweve FMI implements the standard contracts with shared model, state and lifecycle rules, so variables, clocks, derivatives and saved state keep their declared identity when a supported execution form changes. A conformance test can compare value references and state transitions before it compares outputs. A difference found there points at the shared subsystem rather than at whichever interface the host happened to select.","open-source-fmi.section.fmi-eng-contract.secondaryKicker":"What remains common","open-source-fmi.section.fmi-eng-contract.secondaryLeft":"The static model declares value references, types, dimensions, causality, variability, initial policy, dependencies, states, derivatives, indicators and clocks. A live instance adds current values, mode, time, solver state and statistics. Model Exchange lets the host own integration. Co-Simulation lets the instance own communication steps. Scheduled Execution lets clocks activate model partitions. The execution form changes who drives the work, not what the model is. That is why a host can switch form without the value references, clocks or saved state acquiring a new identity.","open-source-fmi.section.fmi-eng-contract.detailKicker":"Why this matters to implementers","open-source-fmi.section.fmi-eng-contract.secondaryRight":"An FMI 3 model description declares its value table, dependencies, derivatives, clocks and persistent state for the interface types it supports. A host can integrate Model Exchange, let a Co-Simulation instance advance itself or activate Scheduled Execution partitions when those capabilities are present. Capability, lifecycle and state checks follow the declared interface set. A failure therefore identifies the shared subsystem or the selected interface boundary, keeping evidence consistent across host choices and deployments.","open-source-fmi.section.fmi-eng-contract.pill.1":"MODEL EXCHANGE","open-source-fmi.section.fmi-eng-contract.pill.2":"CO-SIMULATION","open-source-fmi.section.fmi-eng-contract.pill.3":"SCHEDULED","open-source-fmi.section.fmi-eng-contract.footer":"The interface chooses who drives the run. The numerical type decides what every drive computes.","open-source-fmi.section.fmi-eng-numerus.eyebrow":"The numerical language","open-source-fmi.section.fmi-eng-numerus.headlineLead":"Floats cross the boundary","open-source-fmi.section.fmi-eng-numerus.headlineAccent":"the run stays deterministic","open-source-fmi.section.fmi-eng-numerus.body":"FMI exposes Float32 and Float64 because that is the standard boundary. Dweve FMI converts those values into deterministic Numerus representations and keeps real-valued computation inside that type system: state, solver stages, model mathematics, residuals, tolerances, transformations and backend kernels. The conversion policy is part of the run contract rather than a cast hidden in a binding. An overflow, rounding choice or unsupported representation can therefore stop the run with its boundary and policy named.","open-source-fmi.section.fmi-eng-numerus.secondaryKicker":"The formats","open-source-fmi.section.fmi-eng-numerus.secondaryLeft":"Q31.32 provides the general engineering range and resolution. Q16.16 serves tighter control and edge paths. Decimal formats keep quantities that must remain exact in decimal. Integer, Boolean, string, binary and clock values retain direct typed representations. Conversion is explicit, checked and named, which means a value that will not fit becomes a fault at the boundary rather than a nearby number hidden inside a trajectory.","open-source-fmi.section.fmi-eng-numerus.detailKicker":"The deterministic contract is wider than storage","open-source-fmi.section.fmi-eng-numerus.secondaryRight":"Numerus keeps deterministic arithmetic inside the run, not only in stored values. Its selected fixed-point or decimal format governs arithmetic, comparisons, reductions, solver coefficients and range checks. FMI values remain interoperable at the boundary, while diagnostics retain the conversion policy and selected backend. A reviewer can therefore compare the numerical contract that produced two runs, not only their final values.","open-source-fmi.section.fmi-eng-numerus.pill.1":"FIXED POINT","open-source-fmi.section.fmi-eng-numerus.pill.2":"EXACT DECIMAL","open-source-fmi.section.fmi-eng-numerus.pill.3":"CONVERSION CHECKED","open-source-fmi.section.fmi-eng-numerus.footer":"A deterministic number is useful only when the solver preserves its contract.","open-source-fmi.section.fmi-eng-solvers.eyebrow":"ODE, DAE, SDE and nonlinear systems","open-source-fmi.section.fmi-eng-solvers.headlineLead":"The model declares the problem","open-source-fmi.section.fmi-eng-solvers.headlineAccent":"the solver registry routes it","open-source-fmi.section.fmi-eng-solvers.body":"Dweve FMI does not expose one hard-coded integrator as the meaning of simulation. The runtime classifies the system and selects from registered solver families: explicit and adaptive ODE methods, implicit stiff methods, DAE routes, stochastic methods, nonlinear roots, interval methods and coupled-loop solvers. The selected family carries its assumptions, tolerance and stopping rule into the result record, so another run does not depend on an undocumented default. A host can reject a method whose capabilities do not fit the model before the first step. Solver choice belongs beside the output, not in a hidden runtime log. The trace can show whether a result was accepted, limited by a bound or returned after a recorded fallback. A nonlinear solve is therefore an explicit numerical contract, not an accidental path through a library.","open-source-fmi.section.fmi-eng-solvers.secondaryKicker":"One result contract","open-source-fmi.section.fmi-eng-solvers.secondaryLeft":"Every registered method returns through the same diagnostic shape. The caller receives accepted state, last successful time, iteration and evaluation counts, residuals, error estimates, rejected steps, event locations, convergence status and the named bound behind any refusal. That common result is what lets the runtime move between a fixed-step control loop, a stiff plant model and an algebraic co-simulation loop without making the surrounding application learn a new language each time.","open-source-fmi.section.fmi-eng-solvers.detailKicker":"Selection is part of the run record","open-source-fmi.section.fmi-eng-solvers.secondaryRight":"Dispatch records the stiffness, mass matrix, stochastic terms, tolerances, event density, derivatives and backend capabilities behind its selection. A programme can pin a method for repeatability or a reference comparison. Configuration is validated against the chosen route, and any fallback enters the trace with its reason. Solver choice therefore remains an engineering decision that can be repeated, compared and challenged rather than an implicit runtime preference. The named route stays with its result.","open-source-fmi.section.fmi-eng-solvers.pill.1":"ODE","open-source-fmi.section.fmi-eng-solvers.pill.2":"DAE","open-source-fmi.section.fmi-eng-solvers.pill.3":"SDE","open-source-fmi.section.fmi-eng-solvers.pill.4":"NONLINEAR","open-source-fmi.section.fmi-eng-solvers.pill.5":"INTERVAL","open-source-fmi.section.fmi-eng-solvers.footer":"Solvers advance the model. FMI modes decide when that advance is legal.","open-source-fmi.section.fmi-eng-lifecycle.eyebrow":"FMI 3 lifecycle enforcement","open-source-fmi.section.fmi-eng-lifecycle.headlineLead":"A legal call is a transition","open-source-fmi.section.fmi-eng-lifecycle.headlineAccent":"not a hopeful function call","open-source-fmi.section.fmi-eng-lifecycle.body":"FMI 3 defines which operations are legal in each lifecycle mode. Dweve FMI implements that contract as an explicit state machine. Instantiate, configure, initialise, enter event or continuous-time execution, step, activate partitions, terminate or fail: every transition is checked before the operation touches model state. The check happens at the boundary that receives the call, so an illegal sequence cannot become a partially updated instance. Hosts can test the refusal itself and retain the mode that made it correct. The same transition record travels with a snapshot, which keeps restore and replay honest when a host resumes on another process. A resumed instance therefore starts in a declared mode rather than in whatever mode the host assumed it was in.","open-source-fmi.section.fmi-eng-lifecycle.secondaryKicker":"The refusal carries context","open-source-fmi.section.fmi-eng-lifecycle.secondaryLeft":"A wrong-mode call returns the current mode, the required mode, the attempted operation and the relevant instance. Where the standard provides a precise rule, the diagnostic can retain that reference as well. Terminal states remain terminal. The runtime never turns an illegal sequence into a half-mutated instance that later produces a plausible result. That makes lifecycle failures assertable in tests and actionable in an FMI host.","open-source-fmi.section.fmi-eng-lifecycle.detailKicker":"Mode is part of persistence and replay","open-source-fmi.section.fmi-eng-lifecycle.secondaryRight":"Snapshots preserve lifecycle mode, pending transitions, event iteration and interface capabilities as well as values. Restoring numbers into the wrong FMI mode can allow an illegal call or refuse a legal one. Standard status codes remain available to a host, while structured diagnostics retain the exact transition, instance, time and operation. Scheduled partitions and Co-Simulation communication points are checked against the same record.","open-source-fmi.section.fmi-eng-lifecycle.pill.1":"CURRENT MODE","open-source-fmi.section.fmi-eng-lifecycle.pill.2":"REQUIRED MODE","open-source-fmi.section.fmi-eng-lifecycle.pill.3":"OPERATION NAMED","open-source-fmi.section.fmi-eng-lifecycle.footer":"A legal mode can still contain an event, and the event may sit between communication points.","open-source-fmi.section.fmi-eng-events-clocks.eyebrow":"Continuous and scheduled behaviour","open-source-fmi.section.fmi-eng-events-clocks.headlineLead":"A zero crossing, a clock tick","open-source-fmi.section.fmi-eng-events-clocks.headlineAccent":"and a partition share a line","open-source-fmi.section.fmi-eng-events-clocks.body":"Physical models do not change only at the end of a requested step. A threshold is crossed, a contact closes, a clock fires or a scheduled partition becomes eligible. Dweve FMI keeps those moments inside one ordered timeline and hands control back through the FMI 3 mechanisms that describe what actually happened. The timeline records the interior point where control changed hands, not only the requested endpoint. That distinction lets a host replay an event-heavy step without guessing which callback or partition ran first.","open-source-fmi.section.fmi-eng-events-clocks.secondaryKicker":"Inside the step","open-source-fmi.section.fmi-eng-events-clocks.secondaryLeft":"Event indicators are tracked with zero as its own state, root solvers locate crossings, and the runtime restarts continuous execution after discrete state has settled. Intermediate-update callbacks expose progress before the communication point and support early return when a clock, event, requested interior time or host policy requires it. Scheduled Execution uses the same clock state and dependency information to activate model partitions in a reproducible order.","open-source-fmi.section.fmi-eng-events-clocks.detailKicker":"EXPLICIT ORDERING","open-source-fmi.section.fmi-eng-events-clocks.secondaryRight":"A step may include internal solver steps, indicator evaluations, roots, discrete iteration, callbacks and clock activations. Dweve FMI records their order and the point at which control returns. Tie-breaking, dependency order and the next activation remain state, while the host receives the standard event, early-return and last-successful-time result. Event-heavy and scheduled runs therefore remain inspectable and replayable after recovery.","open-source-fmi.section.fmi-eng-events-clocks.pill.1":"ROOT LOCATION","open-source-fmi.section.fmi-eng-events-clocks.pill.2":"EARLY RETURN","open-source-fmi.section.fmi-eng-events-clocks.pill.3":"CLOCKS","open-source-fmi.section.fmi-eng-events-clocks.pill.4":"PARTITIONS","open-source-fmi.section.fmi-eng-events-clocks.footer":"One instance has a timeline. A coupled system must make several timelines agree.","open-source-fmi.section.fmi-eng-backends.eyebrow":"Local execution backends","open-source-fmi.section.fmi-eng-backends.headlineLead":"One model can be interactive","open-source-fmi.section.fmi-eng-backends.headlineAccent":"parallel, pipelined or embedded","open-source-fmi.section.fmi-eng-backends.body":"The backend interface lets the runtime place the same numerical work on hardware suited to its shape. Small models need low overhead. Large ensembles need parallel throughput. Fixed graphs need deterministic latency. Embedded systems need bounded memory and a runtime that can operate without the full standard library. Placement remains a deployment choice because the model, state and diagnostic contract stay fixed. A comparison can therefore isolate a backend change instead of comparing two implementations that drifted apart.","open-source-fmi.section.fmi-eng-backends.secondaryKicker":"Four local postures","open-source-fmi.section.fmi-eng-backends.secondaryLeft":"The CPU path dispatches scalar and SIMD kernels at runtime across the current x86 and Arm instruction families. GPU execution batches derivative, state and ensemble work where transfer cost is justified. FPGA execution compiles stable computation graphs into fixed pipelines for hardware-in-the-loop and real-time paths. The edge backend minimises allocation, supports constrained precision where declared, and carries Dweve FMI into `no_std` Arm and RISC-V environments.","open-source-fmi.section.fmi-eng-backends.detailKicker":"CAPABILITY-GUIDED FALLBACK","open-source-fmi.section.fmi-eng-backends.secondaryRight":"Each backend publishes its capabilities before selection. A GPU may need a supported batch and state layout, an FPGA a stable graph and artefact, and an edge target a defined memory and numeric budget. Another approved target may be selected, but the runtime records it. Parity checks compare declared-equivalent arithmetic and solver paths, then identify the first divergent value, state or step when equivalence does not hold. The report names the approved comparison.","open-source-fmi.section.fmi-eng-backends.pill.1":"SIMD CPU","open-source-fmi.section.fmi-eng-backends.pill.2":"GPU","open-source-fmi.section.fmi-eng-backends.pill.3":"FPGA","open-source-fmi.section.fmi-eng-backends.pill.4":"NO_STD EDGE","open-source-fmi.section.fmi-eng-backends.footer":"Local hardware solves one placement problem. Large co-simulations add a second: where every FMU should live.","open-source-fmi.section.fmi-eng-orchestration.eyebrow":"Multi-FMU orchestration","open-source-fmi.section.fmi-eng-orchestration.headlineLead":"Several FMUs remain separate","open-source-fmi.section.fmi-eng-orchestration.headlineAccent":"and execute as one system","open-source-fmi.section.fmi-eng-orchestration.body":"Co-simulation is not a loop that calls each FMU in whatever order a container happens to return them. Dweve FMI turns connections into an explicit dependency graph, derives execution levels, propagates typed values and coordinates communication points across the complete coupled system. The graph is the execution plan and the review artefact at the same time. Changing one connection or delay produces a named graph change rather than an unexplained change in call order. Ownership follows the graph: suppliers remain responsible for model internals, while the integrator can review scheduling, placement and loop policy in one place.","open-source-fmi.section.fmi-eng-orchestration.secondaryKicker":"What the graph provides","open-source-fmi.section.fmi-eng-orchestration.secondaryLeft":"Acyclic components are ordered through a stable topological schedule. Independent FMUs at the same level can execute in parallel. Every connection names source, target, value references, transformation and any declared delay. Communication-point checks ensure that the master and each instance agree about the moment being advanced. The graph remains inspectable, serialisable and available to diagnostics, placement and provenance.","open-source-fmi.section.fmi-eng-orchestration.detailKicker":"Connections are versioned engineering artefacts","open-source-fmi.section.fmi-eng-orchestration.secondaryRight":"System-level behaviour lives in the versioned connection graph as well as in each FMU. The graph records transformations, delays, execution policy and communication settings, and can be archived beside checkpoints and results. Placement, provenance and supplier responsibility all use the same artefact: suppliers own model internals, while the integrator owns connection semantics, scheduling and loop policy. The archived graph remains the review point.","open-source-fmi.section.fmi-eng-orchestration.pill.1":"TYPED CONNECTIONS","open-source-fmi.section.fmi-eng-orchestration.pill.2":"EXECUTION LEVELS","open-source-fmi.section.fmi-eng-orchestration.pill.3":"PARALLEL","open-source-fmi.section.fmi-eng-orchestration.footer":"A graph with no complete order contains a loop, and a loop needs a declared solver.","open-source-fmi.section.fmi-eng-algebraic-loops.eyebrow":"Strongly connected FMUs","open-source-fmi.section.fmi-eng-algebraic-loops.headlineLead":"A cycle becomes a solver problem","open-source-fmi.section.fmi-eng-algebraic-loops.headlineAccent":"not a scheduling accident","open-source-fmi.section.fmi-eng-algebraic-loops.body":"When FMU A needs the current output of B and B needs the current output of A, no topological order can satisfy the connection graph. Dweve FMI detects the strongly connected component, treats it as an algebraic-loop group and dispatches the configured nonlinear route. The loop is named before iteration begins, so its residual and stopping rule can be reviewed as part of the model. If it fails, the result points to the group and the values that did not settle rather than reporting only a generic step error.","open-source-fmi.section.fmi-eng-algebraic-loops.secondaryKicker":"Several legitimate endings","open-source-fmi.section.fmi-eng-algebraic-loops.secondaryLeft":"Fixed-point iteration serves contractive loops. Relaxation can stabilise a route that would otherwise oscillate. Newton-based solving handles loops whose local Jacobian is available or can be estimated. A declared timestep delay can turn a same-step cycle into a causal sequence. Every route has a convergence norm, tolerance, iteration bound and residual history. A failure names the whole loop group and the values that did not settle under the stated rule.","open-source-fmi.section.fmi-eng-algebraic-loops.detailKicker":"DECLARED CONVERGENCE RULE","open-source-fmi.section.fmi-eng-algebraic-loops.secondaryRight":"Loop configuration names the variables, scaling, norm, tolerance, relaxation and stopping rule behind a residual. Newton routes retain a Jacobian and linear-solver policy; fixed-point routes can retain iterate history. That lets the runtime distinguish slow convergence, oscillation, singularity and divergence. A delay-based break records its delay and history semantics, making the added staleness part of the modelled system.","open-source-fmi.section.fmi-eng-algebraic-loops.pill.1":"SCC DETECTED","open-source-fmi.section.fmi-eng-algebraic-loops.pill.2":"FIXED POINT","open-source-fmi.section.fmi-eng-algebraic-loops.pill.3":"NEWTON","open-source-fmi.section.fmi-eng-algebraic-loops.pill.4":"DELAY EDGE","open-source-fmi.section.fmi-eng-algebraic-loops.footer":"A coupled system may outgrow one machine. The same graph becomes the placement plan.","open-source-fmi.section.fmi-eng-distributed.eyebrow":"Multi-node simulation","open-source-fmi.section.fmi-eng-distributed.headlineLead":"Place the FMUs across nodes","open-source-fmi.section.fmi-eng-distributed.headlineAccent":"keep one coordinated run","open-source-fmi.section.fmi-eng-distributed.body":"Dweve FMI distributes simulation by placing model instances or partitions from the orchestration graph onto nodes. The model is not rewritten into a networking API. Connections that cross a node boundary become transported state exchanges under the same typed connection and communication-point contract. A recovery record can name the old placement, the new placement and every boundary value exchanged between them. Distribution changes where the work runs, not what the run means. A node failure can therefore be treated as a placement event with a declared recovery path, not as a new numerical model to validate from scratch. The recovery record is the same object a reviewer reads afterwards, so placement history stays part of the run rather than of the cluster log.","open-source-fmi.section.fmi-eng-distributed.secondaryKicker":"Local freedom, global order","open-source-fmi.section.fmi-eng-distributed.secondaryLeft":"Each node in a distributed Dweve FMI run may use the local backend that best fits its workload. A CPU node can host control models while GPU nodes run ensembles and an FPGA node handles a fixed real-time partition. The distributed layer coordinates time, boundary values, checkpoint state, retries and node faults. Placement can account for dependencies and data locality so a large co-simulation does not spend its life moving state that could have remained together.","open-source-fmi.section.fmi-eng-distributed.detailKicker":"A consistent checkpoint spans placement","open-source-fmi.section.fmi-eng-distributed.secondaryRight":"Checkpointing and communication-point commitment stay coordinated across nodes. Each node records local state, solver state and boundary sequences under one global run version; a checkpoint completes only after exchanged values agree. Recovery can restore the old placement or choose another. The run record retains the selected backend, migration decision, recovery path and declared numerical contract for every affected node.","open-source-fmi.section.fmi-eng-distributed.pill.1":"NODE PLACEMENT","open-source-fmi.section.fmi-eng-distributed.pill.2":"BOUNDARY STATE","open-source-fmi.section.fmi-eng-distributed.pill.3":"GLOBAL TIME","open-source-fmi.section.fmi-eng-distributed.footer":"Placement preserves the run. Checkpoints preserve it when the process itself disappears.","open-source-fmi.section.fmi-eng-state-history.eyebrow":"Checkpoint, restore, replay and branch","open-source-fmi.section.fmi-eng-state-history.headlineLead":"The process may stop","open-source-fmi.section.fmi-eng-state-history.headlineAccent":"the simulation does not have to","open-source-fmi.section.fmi-eng-state-history.body":"An FMI instance carries more than continuous state. It carries discrete values, event indicators, clocks, mode, time, solver state, coupling state and the version of the run. Dweve FMI treats that state as a first-class artefact rather than something that exists only inside one process. A compatible restore can be checked against that complete context, while a replay can explain the transitions that led there. The saved point is therefore useful to both an operator recovering work and an engineer reviewing a decision.","open-source-fmi.section.fmi-eng-state-history.secondaryKicker":"From checkpoint to history","open-source-fmi.section.fmi-eng-state-history.secondaryLeft":"A checkpoint is tagged, versioned, length-checked and bound to its run contract. Restoring it either recreates a compatible state or refuses with expected and observed information. Above checkpoints, state-changing events form a replayable history. A run can be reconstructed to a selected point, continued from there or forked into several branches while the parent history remains unchanged. Each branch keeps its parent, decision point and continuation evidence clearly visible to a reviewer.","open-source-fmi.section.fmi-eng-state-history.detailKicker":"Replay and restore answer different questions","open-source-fmi.section.fmi-eng-state-history.secondaryRight":"Restore resumes a compatible saved state. Replay reconstructs the recorded inputs, transitions and decisions that reached it. A scenario can replay to a selected point and fork without changing the parent history. State carries compatibility information, while history carries provenance and causation. Together they preserve the model, graph, solver policy, backend profile and resources another environment needs to continue. A reviewer can see both the recovered state and the decision trail that led there.","open-source-fmi.section.fmi-eng-state-history.pill.1":"CHECKPOINT","open-source-fmi.section.fmi-eng-state-history.pill.2":"RESTORE","open-source-fmi.section.fmi-eng-state-history.pill.3":"REPLAY","open-source-fmi.section.fmi-eng-state-history.pill.4":"FORK","open-source-fmi.section.fmi-eng-state-history.footer":"A persistent simulation can continue into operation, where model state meets measured state.","open-source-fmi.section.fmi-eng-twin-bridge.eyebrow":"Bidirectional operational continuity","open-source-fmi.section.fmi-eng-twin-bridge.headlineLead":"Measured state comes in","open-source-fmi.section.fmi-eng-twin-bridge.headlineAccent":"simulated state goes back","open-source-fmi.section.fmi-eng-twin-bridge.body":"The Dweve Twin bridge connects FMI value references to a live event-sourced representation of the asset. It is not a one-way telemetry exporter. Mappings can move values from simulation to Twin, from Twin to simulation or in both directions, with transformation and validation applied at the boundary. Each transfer keeps its direction and authority visible, so a derived estimate cannot silently replace a measured input. The bridge is part of the simulation contract, not an after-the-fact dashboard feed.","open-source-fmi.section.fmi-eng-twin-bridge.secondaryKicker":"Three synchronisation postures","open-source-fmi.section.fmi-eng-twin-bridge.secondaryLeft":"Real-time mode synchronises critical values on the step that produced them. Batch mode amortises high-volume state across a configured buffer. Hybrid mode applies both according to variable criticality and mapping policy. Every sync operation records source, target, direction, simulation time, processing time, validity time and the mapping that was applied. Conflicts are detected before one value silently replaces the other.","open-source-fmi.section.fmi-eng-twin-bridge.detailKicker":"Bridge state is part of simulation continuity","open-source-fmi.section.fmi-eng-twin-bridge.secondaryRight":"The bridge persists its transfer sequence, batch state, mapping version, conflicts, transport status and observed Twin version. Without that state, restart could duplicate events or use stale values. Bidirectional mappings also distinguish direction from authority: Twin can own a measurement while the FMU owns a derived estimate. One model can synchronise critical pressure immediately, batch vibration and publish a predicted margin after a solver step.","open-source-fmi.section.fmi-eng-twin-bridge.pill.1":"REAL-TIME","open-source-fmi.section.fmi-eng-twin-bridge.pill.2":"BATCH","open-source-fmi.section.fmi-eng-twin-bridge.pill.3":"HYBRID","open-source-fmi.section.fmi-eng-twin-bridge.pill.4":"BIDIRECTIONAL","open-source-fmi.section.fmi-eng-twin-bridge.footer":"Twin keeps the history. Standard FMI hosts still need a familiar way into the runtime.","open-source-fmi.section.fmi-eng-ffi.eyebrow":"Host interoperability","open-source-fmi.section.fmi-eng-ffi.headlineLead":"The host calls the standard ABI","open-source-fmi.section.fmi-eng-ffi.headlineAccent":"the implementation stays Rust","open-source-fmi.section.fmi-eng-ffi.body":"Dweve FMI's model, state, solver, runtime, orchestration and backend layers are implemented in Rust. The `fmi-ffi` crate compiles as a `cdylib` and exports the complete FMI 3 `extern \"C\"` function table, so existing FMI hosts load Dweve FMI FMUs through the same dynamic-library contract they use for any other compliant FMU. The boundary translates the standard call surface once and leaves the model logic in the shared Rust runtime. A host can therefore adopt the ABI without accepting a second implementation of state, solver or diagnostics.","open-source-fmi.section.fmi-eng-ffi.secondaryKicker":"A complete surface, not a demo binding","open-source-fmi.section.fmi-eng-ffi.secondaryLeft":"The ABI covers instantiation, lifecycle, typed values, FMU state, derivatives, clocks, intermediate updates, Co-Simulation and Scheduled Execution functions. Entry points translate handles, pointers, arrays and FMI values into the Rust runtime, validate the boundary, then return standard FMI status codes. Structured internal diagnostics remain available for hosts that expose richer error reporting. Every layer named here publishes under Apache-2.0. Once it does, the implementation behind the standard boundary can be inspected and pinned directly.","open-source-fmi.section.fmi-eng-ffi.detailKicker":"The FFI layer remains intentionally thin","open-source-fmi.section.fmi-eng-ffi.secondaryRight":"`fmi-ffi` translates the ABI, validates handles, pointers and arrays, adapts callbacks and converts standard FMI values into the Rust runtime. It does not duplicate model or solver logic in C. Rust-native calls and dynamically loaded FMUs therefore exercise the same state, lifecycle and diagnostic paths. That keeps standard-host use and Rust-native use aligned at the implementation boundary. Hosts retain standard FMI statuses, while integrations that need more detail can expose the structured context recorded by the runtime.","open-source-fmi.section.fmi-eng-ffi.pill.1":"RUST IMPLEMENTATION","open-source-fmi.section.fmi-eng-ffi.pill.2":"FULL FMI3 TABLE","open-source-fmi.section.fmi-eng-ffi.pill.3":"CDYLIB","open-source-fmi.section.fmi-eng-ffi.footer":"The host sees FMI 3. The complete run behind it remains one continuous Rust system.","open-source-fmi.section.fmi-biz-lifecycle.eyebrow":"The programme-level difference","open-source-fmi.section.fmi-biz-lifecycle.headlineLead":"The model does not finish","open-source-fmi.section.fmi-biz-lifecycle.headlineAccent":"when the design study does","open-source-fmi.section.fmi-biz-lifecycle.body":"Most organisations pay for the same system several times. Engineering builds the analysis model. Test builds the co-simulation. Performance teams build an accelerated version. Embedded teams recreate the important equations for the controller. Operations commissions a digital twin integration after the physical asset is already running. One FMI 3 contract lets those teams change the host, solver or backend without changing the model identity. The programme can retire a translation when a phase ends instead of carrying two competing versions into the next review. Every translation that stays alive is another place where two versions of the same system can disagree, and somebody has to reconcile them before each review.","open-source-fmi.section.fmi-biz-lifecycle.secondaryKicker":"What Dweve FMI changes","open-source-fmi.section.fmi-biz-lifecycle.secondaryLeft":"Dweve FMI gives those stages one FMI 3 model contract. The solver, backend, coupling and deployment can change without moving the programme into a different modelling system. State and provenance can continue into Dweve Twin when the asset becomes operational. The commercial benefit is not one cheaper simulation run. It is fewer translations, fewer parallel implementations and fewer places where two models of the same machine quietly stop agreeing. It also protects the operating evidence.","open-source-fmi.section.fmi-biz-lifecycle.detailKicker":"The handover cost is usually hidden","open-source-fmi.section.fmi-biz-lifecycle.secondaryRight":"Every split also creates its own release cadence, validation baseline, mapping table and group of specialists. When an operating result differs from an engineering prediction, the programme must first establish whether both systems still mean the same thing. Keeping the FMI model, variable identity, solver policy and state format across phases removes that detour. Target-specific work remains, but it sits around one contract. Leadership has fewer artefacts to approve, archive and maintain.","open-source-fmi.section.fmi-biz-lifecycle.pill.1":"ONE MODEL CONTRACT","open-source-fmi.section.fmi-biz-lifecycle.pill.2":"DESIGN TO OPERATION","open-source-fmi.section.fmi-biz-lifecycle.footer":"One model inside the organisation is valuable. One standard across suppliers is what makes the system scale.","open-source-fmi.section.fmi-biz-suppliers.eyebrow":"Interoperable model supply","open-source-fmi.section.fmi-biz-suppliers.headlineLead":"Keep the supplier boundaries","open-source-fmi.section.fmi-biz-suppliers.headlineAccent":"remove the integration ambiguity","open-source-fmi.section.fmi-biz-suppliers.body":"A controller, a valve, a battery, a drivetrain or a thermal system may come from different suppliers, each protecting its own model and release cycle. FMI 3 is valuable because those models can remain separately packaged. Dweve FMI adds a complete runtime around that boundary: import, schema validation, capability detection, typed connection and coordinated execution. The package stays supplier-owned while the integrator owns the connection graph and the acceptance record. A release can therefore be checked at intake without requiring source disclosure or trusting an opaque binary by default.","open-source-fmi.section.fmi-biz-suppliers.secondaryKicker":"A safer intake","open-source-fmi.section.fmi-biz-suppliers.secondaryLeft":"An FMU archive is read before its native binary is trusted. The model description, FMI version, instantiation token, interface types, variables, clocks, dependencies and archive layout are validated. Extraction remains inside the intended destination. The runtime can report which requirement is missing before an engineer spends a week diagnosing the supplier's model through failed host calls. Execution remains a deliberate next step, not a side effect of inspecting the package. The intake gate names what passed.","open-source-fmi.section.fmi-biz-suppliers.detailKicker":"The runtime creates a neutral integration layer","open-source-fmi.section.fmi-biz-suppliers.secondaryRight":"Suppliers can keep an FMU as a protected binary while the programme controls its connections, schedule, validation and observation. Source disclosure may be unrealistic, but accepting an unchecked black box is weak. FMI 3 defines the package boundary; Dweve FMI makes the host contract inspectable. A supplier can update its FMU without owning the co-simulation master, while the integrator compares capabilities and retains responsibility for connections and loop policy. That boundary remains reviewable in release.","open-source-fmi.section.fmi-biz-suppliers.pill.1":"FMI 3 SUPPLY CHAIN","open-source-fmi.section.fmi-biz-suppliers.pill.2":"VALIDATE FIRST","open-source-fmi.section.fmi-biz-suppliers.pill.3":"DELIBERATE","open-source-fmi.section.fmi-biz-suppliers.footer":"The packages remain separate. Orchestration is what makes them behave as one product.","open-source-fmi.section.fmi-biz-cosimulation.eyebrow":"System integration","open-source-fmi.section.fmi-biz-cosimulation.headlineLead":"Couple the models","open-source-fmi.section.fmi-biz-cosimulation.headlineAccent":"without merging their owners","open-source-fmi.section.fmi-biz-cosimulation.body":"A system-level simulation must coordinate independent models without pretending they were authored as one monolith. Dweve FMI connects FMUs through typed value mappings and builds the dependency graph that decides execution order, parallel work, communication points and algebraic-loop groups. That graph gives integration a reviewable object between supplier releases. A programme can change one FMU, rerun the affected path and show where the difference entered instead of reopening the whole system by hand. Each supplier keeps their own model and their own release cadence, and the graph is the only object the integration team has to agree on before the next run.","open-source-fmi.section.fmi-biz-cosimulation.secondaryKicker":"What the integrator gains","open-source-fmi.section.fmi-biz-cosimulation.secondaryLeft":"Every connection is reviewable. Every execution level is derived. Cycles are named and sent to an approved loop solver. Declared delays remain visible. When a model is at the wrong time, a value cannot be converted or a loop fails to converge, the failure points at the models and operands involved. Integration defects stop being generic simulation failures routed to whichever supplier answers first. The affected connection remains visible.","open-source-fmi.section.fmi-biz-cosimulation.detailKicker":"System-level evidence stays decomposable","open-source-fmi.section.fmi-biz-cosimulation.secondaryRight":"When a combined simulation produces a finding, Dweve FMI retains each FMU's contribution and state rather than only a whole-system chart. The programme identifies the model version, connection, transformation and step at which a divergence entered. It can rerun the graph with one supplier version changed and compare affected paths. Regression narrows, phased replacement stays possible, and a shared operational view remains.","open-source-fmi.section.fmi-biz-cosimulation.pill.1":"TYPED CONNECTIONS","open-source-fmi.section.fmi-biz-cosimulation.pill.2":"DEPENDENCY GRAPH","open-source-fmi.section.fmi-biz-cosimulation.pill.3":"LOOPS","open-source-fmi.section.fmi-biz-cosimulation.footer":"The model graph decides what can run together. The backend layer decides where it runs best.","open-source-fmi.section.fmi-biz-resume.eyebrow":"Persistent simulation state","open-source-fmi.section.fmi-biz-resume.headlineLead":"An interruption costs the gap","open-source-fmi.section.fmi-biz-resume.headlineAccent":"since the last checkpoint","open-source-fmi.section.fmi-biz-resume.body":"Long studies fail for ordinary reasons: a host is patched, a node is replaced, a queue is pre-empted or an operator stops the wrong process. Losing the entire run because the process disappeared turns infrastructure noise into engineering cost. A checkpoint interval makes that exposure explicit: the team can state how much work an interruption may lose and what state is needed to continue. Recovery then becomes part of the study plan rather than a promise made after a failed run.","open-source-fmi.section.fmi-biz-resume.secondaryKicker":"A study with state","open-source-fmi.section.fmi-biz-resume.secondaryLeft":"Dweve FMI checkpoints the complete runtime state required to continue, not only the visible output variables. The programme chooses checkpoint cadence and therefore chooses the maximum work an interruption can lose. A compatible worker can restore the run, continue the solver and preserve the same history. The saved point retains the record that explains how that state was reached. Any saved point can also become the root of a new scenario branch rather than merely an emergency restart for the programme team later.","open-source-fmi.section.fmi-biz-resume.detailKicker":"Checkpoint cadence becomes a cost decision","open-source-fmi.section.fmi-biz-resume.secondaryRight":"Checkpoint cadence is a stated trade-off between storage and repeated work. Because saved state includes solver, clock, mode and bridge context, the programme can calculate that trade-off instead of trusting a save that cannot continue the run. Distributed studies can align checkpoints with node replacement and queue limits. Scenario teams can retain selected decision points more often. The study plan then names the progress an interruption may cost and the moments available for later review or branches.","open-source-fmi.section.fmi-biz-resume.pill.1":"CHECKPOINT","open-source-fmi.section.fmi-biz-resume.pill.2":"RESUME","open-source-fmi.section.fmi-biz-resume.pill.3":"BRANCH","open-source-fmi.section.fmi-biz-resume.pill.4":"MOVE","open-source-fmi.section.fmi-biz-resume.footer":"Saved state protects a study. Twin continuity protects the model after the study becomes operational.","open-source-fmi.section.fmi-biz-live-twin.eyebrow":"From engineering model to operating Twin","open-source-fmi.section.fmi-biz-live-twin.headlineLead":"The model stays useful","open-source-fmi.section.fmi-biz-live-twin.headlineAccent":"after the equipment ships","open-source-fmi.section.fmi-biz-live-twin.body":"The most expensive model is often discarded at the moment it becomes most valuable. Engineering finishes validation, the asset enters service, and operations receives dashboards built from a different data model with none of the simulation's state or assumptions attached. Keeping the FMI model beside the operating record preserves a route back to the validated baseline. Teams can distinguish measured change from model change before either one is treated as a maintenance fact.","open-source-fmi.section.fmi-biz-live-twin.secondaryKicker":"One continuing representation","open-source-fmi.section.fmi-biz-live-twin.secondaryLeft":"The Dweve Twin bridge lets the FMI model remain beside the operating asset. Measured state can update simulation inputs. Predicted values, residuals and scenario outputs can return to Twin. Variable mappings preserve units and transformations. Real-time, batch and hybrid synchronisation let the programme decide which values require immediate consistency and which should move efficiently in groups. That choice can be made per mapping rather than as one programme-wide rule. The mapping remains attributable after handover.","open-source-fmi.section.fmi-biz-live-twin.detailKicker":"COMMISSIONING CONTINUES","open-source-fmi.section.fmi-biz-live-twin.secondaryRight":"Commissioning replaces assumptions with measured parameters. In a disconnected stack, those updates are copied into a new operational model with little traceability to the engineering baseline. Through the Twin bridge, accepted calibration, parameter changes and mapping versions enter the same history. The organisation can see which assumptions survived and when the operating model diverged. Warranty, maintenance and improvement work stays attached to attributable change rather than an undocumented variant.","open-source-fmi.section.fmi-biz-live-twin.pill.1":"LIVE DATA IN","open-source-fmi.section.fmi-biz-live-twin.pill.2":"PREDICTED STATE OUT","open-source-fmi.section.fmi-biz-live-twin.pill.3":"ONE HISTORY","open-source-fmi.section.fmi-biz-live-twin.footer":"A live model will eventually disagree with a measurement. Decide what happens before that morning arrives.","open-source-fmi.section.fmi-biz-conflict-policy.eyebrow":"Simulation and operational state","open-source-fmi.section.fmi-biz-conflict-policy.headlineLead":"Two values can both be legitimate","open-source-fmi.section.fmi-biz-conflict-policy.headlineAccent":"only one may drive the next step","open-source-fmi.section.fmi-biz-conflict-policy.body":"The simulation predicts 4.10 bar. The operating asset reports 4.32. That difference may be expected model error, a stale sensor, a changed operating condition or the first sign of a fault. A bridge that simply overwrites one with the other removes the evidence before anybody can decide. A declared policy can automate ordinary conflicts and reserve a person for safety-relevant values. The record keeps the competing values and the rule that selected the next one, so a later review can challenge the decision without reconstructing message timing.","open-source-fmi.section.fmi-biz-conflict-policy.secondaryKicker":"Policy per variable","open-source-fmi.section.fmi-biz-conflict-policy.secondaryLeft":"Dweve FMI lets the programme declare the authority and conflict policy for each mapping. The simulation may win for a derived value no sensor observes. Twin may win for an instrumented input. Most-recent or more-specific policies can settle ordinary values automatically. Safety-relevant or disputed values can require a person. The rule can record who approved it and when it is reconsidered. The conflict and resolution are separate provenance events, so the decision remains attributable.","open-source-fmi.section.fmi-biz-conflict-policy.detailKicker":"Authority is explicit instead of accidental","open-source-fmi.section.fmi-biz-conflict-policy.secondaryRight":"Without a declared policy, authority often belongs to the last integration that wrote the field, and that can change with message timing. Dweve FMI makes authority part of each mapping and value role. The organisation can review those rules before operation, reserve manual handling for safety-relevant values and automate the ordinary cases. Conflict handling becomes an operational measure, not an unexplained exception. Reviews can trace that measure to its declared rule and owner.","open-source-fmi.section.fmi-biz-conflict-policy.pill.1":"CONFLICT KEPT","open-source-fmi.section.fmi-biz-conflict-policy.pill.2":"POLICY PER VARIABLE","open-source-fmi.section.fmi-biz-conflict-policy.pill.3":"MANUAL","open-source-fmi.section.fmi-biz-conflict-policy.footer":"Policy settles the current value. Provenance explains every value that crossed the boundary.","open-source-fmi.section.fmi-biz-provenance.eyebrow":"Operational provenance","open-source-fmi.section.fmi-biz-provenance.headlineLead":"Where did this number come from","open-source-fmi.section.fmi-biz-provenance.headlineAccent":"is answered by the record itself","open-source-fmi.section.fmi-biz-provenance.body":"A simulation result becomes commercially useful when another team can trace it without calling the engineer who configured the run. Dweve FMI and Dweve Twin retain the route from source model or sensor through mapping, transformation, validation, synchronisation and any conflict decision. The record separates simulation time, processing time and validity time, which prevents a late correction from rewriting what the organisation knew earlier. That distinction shortens incident review and keeps an approved result attributable after handover. The record names the run, the model version and the decision that settled each conflict, so a later reader does not have to reconstruct any of it.","open-source-fmi.section.fmi-biz-provenance.secondaryKicker":"Three kinds of time","open-source-fmi.section.fmi-biz-provenance.secondaryLeft":"Simulation time states when the value belongs inside the model. Processing time states when the bridge handled it. Validity time states the period over which the value should count. Those are different operational questions. A reading can happen at 09:00, arrive at 09:03 and be corrected later with validity beginning at 09:00. Keeping all three lets a review distinguish what happened from what the organisation knew at the time. It also shows when later knowledge corrected the record and why that matters.","open-source-fmi.section.fmi-biz-provenance.detailKicker":"FUTURE REVIEW","open-source-fmi.section.fmi-biz-provenance.secondaryRight":"Provenance does not replace engineering judgement. It lets a future reviewer begin without locating the original engineer. They can identify the model, solver run, sensor, mapping version, transformation and decision behind a value, then involve the right specialist. That shortens supplier disputes, incident triage and calibration reviews. Commercial teams can also show that a result came from an approved model and mapping without exposing the supplier FMU's internal implementation.","open-source-fmi.section.fmi-biz-provenance.pill.1":"SOURCE","open-source-fmi.section.fmi-biz-provenance.pill.2":"TRANSFORM","open-source-fmi.section.fmi-biz-provenance.pill.3":"THREE TIMES","open-source-fmi.section.fmi-biz-provenance.pill.4":"RESOLUTION","open-source-fmi.section.fmi-biz-provenance.footer":"Provenance makes the history defensible. Standard host compatibility makes adoption practical.","open-source-fmi.section.fmi-biz-host-fit.eyebrow":"Integration without a host rewrite","open-source-fmi.section.fmi-biz-host-fit.headlineLead":"Your host sees the standard","open-source-fmi.section.fmi-biz-host-fit.headlineAccent":"not a migration to Rust","open-source-fmi.section.fmi-biz-host-fit.body":"Simulation organisations already own authoring tools, test benches, orchestration environments and validation workflows built around the FMI function table. A new runtime that requires every host to become a Rust application would make implementation quality irrelevant because the integration cost would stop adoption. The standard ABI lets a team compare one FMU in its existing host before it changes the surrounding workflow. Adoption can therefore be staged around evidence, not forced as a platform migration.","open-source-fmi.section.fmi-biz-host-fit.secondaryKicker":"Standard boundary, Rust implementation","open-source-fmi.section.fmi-biz-host-fit.secondaryLeft":"`fmi-ffi` exports the complete FMI 3 `extern \"C\"` API from a Rust `cdylib`. The host loads the library through its existing dynamic-loading path and calls the standard lifecycle, typed-value, step, state, derivative, clock and partition functions. The implementation behind those calls remains Rust-native. The organisation gains the runtime without replacing the tools around it or interrupting existing conformance work.","open-source-fmi.section.fmi-biz-host-fit.detailKicker":"Adoption can be staged","open-source-fmi.section.fmi-biz-host-fit.secondaryRight":"A team can begin by loading one Dweve FMI FMU in its existing host and comparing it with the current model. It can add Rust-native tooling, selected backends or Twin connections only where they help. The standard ABI keeps that first step independent of the final architecture. Existing conformance, test and authoring tools stay useful during the transition, which lets interoperability be proven before wider platform adoption.","open-source-fmi.section.fmi-biz-host-fit.pill.1":"STANDARD FMI3* API","open-source-fmi.section.fmi-biz-host-fit.pill.2":"RUST CDYLIB","open-source-fmi.section.fmi-biz-host-fit.pill.3":"NO REWRITE","open-source-fmi.section.fmi-biz-host-fit.footer":"Compatibility lowers the entry cost. Backend and distribution choices determine how far the same model can scale.","open-source-fmi.section.fmi-biz-scale.eyebrow":"From interactive model to large study","open-source-fmi.section.fmi-biz-scale.headlineLead":"The capacity plan can change","open-source-fmi.section.fmi-biz-scale.headlineAccent":"and the model stays the same","open-source-fmi.section.fmi-biz-scale.body":"Capacity requirements rarely stay where a programme began. A model that was interactive during design may later support calibration sweeps, fleet-level ensembles, distributed system studies or real-time operation. Conventional stacks answer each increase with a specialised rewrite and another validation campaign. Dweve FMI separates local acceleration from graph distribution, so a programme can add capacity at the point that needs it. The same diagnostics and provenance return with the run, keeping acceptance focused on the deployment change.","open-source-fmi.section.fmi-biz-scale.secondaryKicker":"Two independent scaling choices","open-source-fmi.section.fmi-biz-scale.secondaryLeft":"Dweve FMI lets a programme speed local work and distribute the graph independently. GPU or FPGA can speed selected models while other FMUs stay on CPU. Distributed placement moves only parts needing more memory or different hardware. The run returns through the same state, diagnostics and provenance contract, so comparison and acceptance focus on the deployment change. The model contract remains stable while capacity changes.","open-source-fmi.section.fmi-biz-scale.detailKicker":"CAPACITY FOLLOWS DEMAND","open-source-fmi.section.fmi-biz-scale.secondaryRight":"Self-hosted, backend-driven execution makes capacity a question of hardware, scheduling and model shape, not access to a proprietary tier. Teams can reserve GPUs for ensembles, FPGA capacity for low-latency work and CPUs for interactive studies. Distributed placement becomes necessary only when a model exceeds one machine. That avoids paying the operational cost of a cluster for every workload while retaining a route to scale when a programme needs it.","open-source-fmi.section.fmi-biz-scale.pill.1":"ACCELERATE LOCALLY","open-source-fmi.section.fmi-biz-scale.pill.2":"DISTRIBUTE","open-source-fmi.section.fmi-biz-scale.pill.3":"COMPARE","open-source-fmi.section.fmi-biz-scale.footer":"An FMI 3 model built on Dweve FMI can scale and remain self-hosted. The final commercial question is what the organisation is buying.","open-source-fmi.section.fmi-biz-commercial.eyebrow":"Ownership and economics","open-source-fmi.section.fmi-biz-commercial.headlineLead":"Run the models on your estate","open-source-fmi.section.fmi-biz-commercial.headlineAccent":"under a licence you can keep","open-source-fmi.section.fmi-biz-commercial.body":"Dweve FMI publishes under Apache-2.0. Teams can inspect it, build it, embed it in products and operate it without a per-seat or per-run fee. The simulation path does not require a hosted control plane, an account with the runtime vendor or an external decision service. The organisation owns the model, deployment, backend choice, checkpoints and release schedule. Support or managed infrastructure can be bought when useful, but access to the runtime is not metered through a supplier account.","open-source-fmi.section.fmi-biz-commercial.secondaryKicker":"What the organisation owns","open-source-fmi.section.fmi-biz-commercial.secondaryLeft":"The organisation owns the models, the deployment, the backend selection, the checkpoints, the Twin history and the release schedule. It can begin with one Rust library or one FMU and expand into accelerated or distributed execution without renegotiating the right to run the same model. The practical sales case is not simply lower licence spend. It is the removal of a metered dependency from engineering evidence, embedded products and operational twins.","open-source-fmi.section.fmi-biz-commercial.detailKicker":"Support and services remain optional layers","open-source-fmi.section.fmi-biz-commercial.secondaryRight":"Apache-2.0 does not require an organisation to operate alone. Support, validation and managed infrastructure can be bought for their actual value, not as permission to keep running a model. The runtime can be embedded without a later per-unit negotiation. A research team can reproduce an old study without reactivating a subscription, and a regulated operator can pin and inspect an approved version. Those are ownership benefits that outlast the original project.","open-source-fmi.section.fmi-biz-commercial.pill.1":"APACHE-2.0","open-source-fmi.section.fmi-biz-commercial.pill.2":"SELF-HOSTED","open-source-fmi.section.fmi-biz-commercial.pill.3":"YOURS TO EMBED","open-source-fmi.section.fmi-biz-commercial.footer":"One model, one runtime contract and one history, from the first study into operation.","open-source-fmi.section.fmi-con-model-first.eyebrow":"Before the physical machine","open-source-fmi.section.fmi-con-model-first.headlineLead":"A lift, a pump or a vehicle","open-source-fmi.section.fmi-con-model-first.headlineAccent":"is tried out as a model first","open-source-fmi.section.fmi-con-model-first.body":"Long before the first machine is finished, engineers write down how its parts should behave. The model describes motion, heat, pressure, power, control and the way one part affects another. A computer runs that model again and again to find problems while they are still changes to equations rather than failures in equipment. The same model is asked harder questions as the design settles, so the early work is not thrown away once the machine becomes real.","open-source-fmi.section.fmi-con-model-first.secondaryKicker":"What Dweve FMI does","open-source-fmi.section.fmi-con-model-first.secondaryLeft":"Dweve FMI is the system that gives a machine's model a standard shape and runs it. The model can come from one team or from several suppliers. It can be driven as one set of equations, as a self-contained simulation or according to scheduled clocks. The same description remains recognisable as the test grows from one part into the whole machine. It remains the durable shared reference as work expands.","open-source-fmi.section.fmi-con-model-first.detailKicker":"A model is a shared description","open-source-fmi.section.fmi-con-model-first.secondaryRight":"Teams can work on different parts of one machine and still exchange the model in one format. One group may focus on control, another on mechanics, heat or power. Named values move between their computers instead of figures being copied between reports. Finding an unstable connection or limit early can avoid physical prototypes. The description also remains available when the next team needs it.","open-source-fmi.section.fmi-con-model-first.pill.1":"MODEL FIRST","open-source-fmi.section.fmi-con-model-first.pill.2":"TEST BEFORE BUILDING","open-source-fmi.section.fmi-con-model-first.pill.3":"ONE SHAPE","open-source-fmi.section.fmi-con-model-first.footer":"A model is useful once. It becomes infrastructure when it can run wherever the next question needs it.","open-source-fmi.section.fmi-con-many-computers.eyebrow":"Different computers, one model","open-source-fmi.section.fmi-con-many-computers.headlineLead":"A small test and a huge study","open-source-fmi.section.fmi-con-many-computers.headlineAccent":"do not need different models","open-source-fmi.section.fmi-con-many-computers.body":"An engineer may run one model on a laptop to understand a single case. Later, the same team may need thousands of variations, a very fast real-time test or a version that runs inside the equipment. Those jobs need different kinds of computer, but they are still asking questions about the same machine. Keeping one model across all of them is what makes the answers comparable.","open-source-fmi.section.fmi-con-many-computers.secondaryKicker":"How Dweve FMI carries it","open-source-fmi.section.fmi-con-many-computers.secondaryLeft":"Dweve FMI can place the model on an ordinary processor, a graphics processor, a fixed hardware chip built for one repeating job, a small embedded device or several machines working together. The speed, size and power change. The model's named parts, state and history remain the same kind of thing, so results can be compared instead of translated from one separate implementation to another.","open-source-fmi.section.fmi-con-many-computers.detailKicker":"Changing computer should not change the question","open-source-fmi.section.fmi-con-many-computers.secondaryRight":"A faster computer may answer more cases, and a smaller one may have less room, but both can still run the model of the same pump, lift or vehicle. Dweve FMI keeps its names, state and rules consistent while it adapts the calculation to the hardware. A desk result can then be compared with one from a test rig or controller without translating between separately written versions.","open-source-fmi.section.fmi-con-many-computers.pill.1":"LAPTOP","open-source-fmi.section.fmi-con-many-computers.pill.2":"GPU","open-source-fmi.section.fmi-con-many-computers.pill.3":"FIXED HARDWARE","open-source-fmi.section.fmi-con-many-computers.pill.4":"IN THE EQUIPMENT","open-source-fmi.section.fmi-con-many-computers.footer":"One part can run in many places. A complete machine also needs several parts to run together.","open-source-fmi.section.fmi-con-coupled.eyebrow":"Co-simulation in plain words","open-source-fmi.section.fmi-con-coupled.headlineLead":"The controller, motor and load","open-source-fmi.section.fmi-con-coupled.headlineAccent":"stay separate, run as one","open-source-fmi.section.fmi-con-coupled.body":"A complex product is rarely designed by one team. The controller comes from one group, the motor from another and the mechanical system from a third. Each part can keep its own model while Dweve FMI connects the values they exchange and runs the combined system in the right order.","open-source-fmi.section.fmi-con-coupled.secondaryKicker":"Why that matters","open-source-fmi.section.fmi-con-coupled.secondaryLeft":"Nobody has to hand over the inside of their model to create a whole-system test. Dweve FMI knows which output feeds which input, which parts can run at the same time and which parts must wait. When two parts each need the other's answer first, it identifies the loop and applies the agreed way of settling it instead of quietly choosing an order. The connection stays visible to the whole team.","open-source-fmi.section.fmi-con-coupled.detailKicker":"The connections are part of the test","open-source-fmi.section.fmi-con-coupled.secondaryRight":"The test records more than the models. It records which value travels between them, its unit and which part runs first. That matters when something fails: a wrong motor answer differs from a correct answer connected to the wrong controller input. Keeping those connections visible helps the people responsible for the whole machine decide whether the problem lies inside one part or between them.","open-source-fmi.section.fmi-con-coupled.pill.1":"SEPARATE MODELS","open-source-fmi.section.fmi-con-coupled.pill.2":"ONE SYSTEM TEST","open-source-fmi.section.fmi-con-coupled.pill.3":"ORDER SET","open-source-fmi.section.fmi-con-coupled.footer":"The complete machine can now be tested. The next useful thing is being able to stop and continue later.","open-source-fmi.section.fmi-con-save.eyebrow":"A simulation with memory","open-source-fmi.section.fmi-con-save.headlineLead":"Stop at this moment","open-source-fmi.section.fmi-con-save.headlineAccent":"open it again from the same place","open-source-fmi.section.fmi-con-save.body":"A long test may run for hours or days. Dweve FMI can save the full moment: where time had reached, what every value was, which mode the model was in, which clocks were waiting and what the solver was doing. The process may end, but that saved moment remains. Opening it again starts from that point rather than from the beginning of the test.","open-source-fmi.section.fmi-con-save.secondaryKicker":"More than recovery","open-source-fmi.section.fmi-con-save.secondaryLeft":"Opening the save lets the run continue without starting at the beginning. The same saved moment can also be used more than once. One branch can try a different controller setting, another can try a different load and the original can continue unchanged. The alternatives begin from the same point, which makes their differences meaningful.","open-source-fmi.section.fmi-con-save.detailKicker":"The saved moment can be shared","open-source-fmi.section.fmi-con-save.secondaryRight":"A complete save can move to another compatible computer or remain with the project. Another engineer can then continue the study later without relying on the original machine. The save identifies its model and settings, so it is not quietly opened against a different version. Saving becomes part of the test, not a screenshot of its final chart.","open-source-fmi.section.fmi-con-save.pill.1":"SAVE","open-source-fmi.section.fmi-con-save.pill.2":"CONTINUE","open-source-fmi.section.fmi-con-save.pill.3":"TRY AN ALTERNATIVE","open-source-fmi.section.fmi-con-save.footer":"A saved model can be reopened. A live model can also stay beside the real machine.","open-source-fmi.section.fmi-con-live.eyebrow":"After the machine is built","open-source-fmi.section.fmi-con-live.headlineLead":"Real measurements come in","open-source-fmi.section.fmi-con-live.headlineAccent":"the model's predictions go back","open-source-fmi.section.fmi-con-live.body":"Once the pump, lift or vehicle exists, the model does not have to be filed away. It can continue beside the real equipment as part of its digital twin. Sensors tell it what the machine is doing. The model estimates things that are hard to measure directly and explores what may happen next.","open-source-fmi.section.fmi-con-live.secondaryKicker":"Two directions","open-source-fmi.section.fmi-con-live.secondaryLeft":"A temperature, pressure or position reading can move from the real asset into the model. A predicted wear level, hidden state or future response can move from the model into the Twin. Each connection states what the value is, where it came from and whether it should move immediately or as part of a batch.","open-source-fmi.section.fmi-con-live.detailKicker":"The live connection keeps context","open-source-fmi.section.fmi-con-live.secondaryRight":"A measurement matters more when the model knows its sensor, unit and time. A prediction matters more when the Twin knows the model version and state that produced it. Dweve FMI keeps those details at each crossing, so model and machine can inform each other without unexplained dashboard numbers.","open-source-fmi.section.fmi-con-live.pill.1":"MEASUREMENTS IN","open-source-fmi.section.fmi-con-live.pill.2":"PREDICTIONS OUT","open-source-fmi.section.fmi-con-live.pill.3":"STAYS USEFUL","open-source-fmi.section.fmi-con-live.footer":"The model and the machine will not always agree, and that disagreement should remain visible.","open-source-fmi.section.fmi-con-disagree.eyebrow":"Simulation versus measurement","open-source-fmi.section.fmi-con-disagree.headlineLead":"The model says one thing","open-source-fmi.section.fmi-con-disagree.headlineAccent":"the machine says another","open-source-fmi.section.fmi-con-disagree.body":"A simulation may say the pressure is 4.10 bar while the sensor says 4.32. Simply replacing one number with the other would make the screen tidy and remove the part people need to investigate. Dweve FMI keeps both values and applies the rule chosen for that kind of disagreement.","open-source-fmi.section.fmi-con-disagree.secondaryKicker":"Some are automatic, some are not","open-source-fmi.section.fmi-con-disagree.secondaryLeft":"A normal temperature difference may be settled by whichever value is newer. A measured input may be allowed to replace the prediction. A hidden quantity may remain under the model's authority. A safety-relevant pressure can be held for a person. The decision becomes another line in the history instead of erasing the disagreement that caused it. The reason remains available for review.","open-source-fmi.section.fmi-con-disagree.detailKicker":"A disagreement can become a warning","open-source-fmi.section.fmi-con-disagree.secondaryRight":"Repeated small differences may show that the model needs calibration. A sudden large one may show a sensor fault or a real change in the machine. Keeping both values reveals that pattern. Erasing one would make later charts look clean while removing the evidence needed to explain why the model and machine no longer agree. Apache-2.0 permits inspection of the rule that was applied.","open-source-fmi.section.fmi-con-disagree.pill.1":"BOTH VALUES KEPT","open-source-fmi.section.fmi-con-disagree.pill.2":"RULE NAMED","open-source-fmi.section.fmi-con-disagree.pill.3":"OR A PERSON","open-source-fmi.section.fmi-con-disagree.footer":"A preserved difference can be investigated later, because the whole past remains available.","open-source-fmi.section.fmi-con-reopen.eyebrow":"Time-travel and scenarios","open-source-fmi.section.fmi-con-reopen.headlineLead":"Go back to the moment","open-source-fmi.section.fmi-con-reopen.headlineAccent":"then try another path","open-source-fmi.section.fmi-con-reopen.body":"After an incident, the useful question is rarely only what the final number was. People need to know when the model and the machine began to part, which measurement arrived late, which rule selected a value and what would have happened under another decision. A saved moment lets the same run be opened again and taken down a different path.","open-source-fmi.section.fmi-con-reopen.secondaryKicker":"A navigable history","open-source-fmi.section.fmi-con-reopen.secondaryLeft":"Dweve FMI saves simulation state and Dweve Twin records the crossings around it. Together they let a reviewer reopen a selected moment, replay what happened and branch an alternative from the same state. One branch can keep the original decision. Another can use a different parameter or conflict resolution. The comparison begins from the same past rather than from two separately reconstructed tests. That keeps later comparison honest and repeatable.","open-source-fmi.section.fmi-con-reopen.detailKicker":"The same past can support several questions","open-source-fmi.section.fmi-con-reopen.secondaryRight":"An engineer may ask where the first numerical difference appeared. An operator may ask what information was available before an alarm. A reviewer may ask which person or policy selected a disputed value. Because the saved simulation and Twin history are connected, those people do not need three separately assembled records. They can begin from the same moment and follow the part of the history relevant to their question.","open-source-fmi.section.fmi-con-reopen.pill.1":"REOPEN","open-source-fmi.section.fmi-con-reopen.pill.2":"REPLAY","open-source-fmi.section.fmi-con-reopen.pill.3":"BRANCH","open-source-fmi.section.fmi-con-reopen.pill.4":"COMPARE","open-source-fmi.section.fmi-con-reopen.footer":"The model can be tested, deployed, kept beside the asset and reopened later, without ceasing to be the same model.","open-source-fmi.banner.fmi-biz-provenance-banner.eyebrow":"The operating record","open-source-fmi.banner.fmi-biz-provenance-banner.lead":"Untracked means telemetry.","open-source-fmi.banner.fmi-biz-provenance-banner.leadAccent":"A routed number is evidence.","open-source-fmi.banner.fmi-biz-provenance-banner.paragraph.1":"The value on a dashboard is the end of a chain. A model produced it from a state, solver and parameter set. Or a sensor produced it and a mapping transformed it before the model used it. During a conflict, a policy or a person selected which value would continue. Losing that chain means rebuilding it later from configuration files and recollection.","open-source-fmi.banner.fmi-biz-provenance-banner.paragraph.2":"Dweve FMI and Dweve Twin keep the chain in the same event-sourced history as the operational state. Source, target, direction, transformations, validation, three kinds of time, conflicts and resolutions remain attached. The programme can ask where a value came from, what was known at a past moment and which decision changed the state that followed.","open-source-fmi.banner.fmi-biz-provenance-banner.panel.header":"One operational value","open-source-fmi.banner.fmi-biz-provenance-banner.panel.tag":"complete route","open-source-fmi.banner.fmi-biz-provenance-banner.check.1":"model or sensor source","open-source-fmi.banner.fmi-biz-provenance-banner.check.2":"value reference and Twin aspect","open-source-fmi.banner.fmi-biz-provenance-banner.check.3":"units and transformation","open-source-fmi.banner.fmi-biz-provenance-banner.check.4":"simulation, processing and validity time","open-source-fmi.banner.fmi-biz-provenance-banner.check.5":"validation","open-source-fmi.banner.fmi-biz-provenance-banner.check.6":"conflict policy","open-source-fmi.banner.fmi-biz-provenance-banner.check.7":"resolution event","open-source-fmi.banner.fmi-biz-provenance-banner.verdict":"the route survives the dashboard that displayed the value","open-source-fmi.banner.fmi-biz-provenance-banner.footline":"today's state and tomorrow's investigation read the same history","open-source-fmi.banner.fmi-con-continuity-banner.eyebrow":"The larger idea","open-source-fmi.banner.fmi-con-continuity-banner.lead":"The test finishes.","open-source-fmi.banner.fmi-con-continuity-banner.leadAccent":"The model can keep going.","open-source-fmi.banner.fmi-con-continuity-banner.paragraph.1":"Most people meet a simulation as a chart in a report. The chart is the last page of the run. It does not contain the state that produced it, the exact point where something changed or the model's life after the report was signed.","open-source-fmi.banner.fmi-con-continuity-banner.paragraph.2":"Dweve FMI keeps the run as something that can be saved, opened, continued and connected to the real asset. The model used before manufacture can remain useful during commissioning and operation. A future investigation can reopen the same history rather than asking somebody to recreate the test from a picture.","open-source-fmi.banner.fmi-con-continuity-banner.panel.header":"The model's longer life","open-source-fmi.banner.fmi-con-continuity-banner.panel.tag":"one continuing object","open-source-fmi.banner.fmi-con-continuity-banner.check.1":"tested before manufacture","open-source-fmi.banner.fmi-con-continuity-banner.check.2":"run on different hardware","open-source-fmi.banner.fmi-con-continuity-banner.check.3":"saved during long studies","open-source-fmi.banner.fmi-con-continuity-banner.check.4":"continued after interruption","open-source-fmi.banner.fmi-con-continuity-banner.check.5":"connected to the live asset","open-source-fmi.banner.fmi-con-continuity-banner.check.6":"replayed and branched later","open-source-fmi.banner.fmi-con-continuity-banner.verdict":"the chart is an output; the model and its history remain usable","open-source-fmi.banner.fmi-con-continuity-banner.footline":"a simulation can become part of the system it once only described","open-source-fmi.section.fmi-eng-contract.secondaryLeftKicker":"SHARED MODEL","open-source-fmi.section.fmi-eng-numerus.secondaryLeftKicker":"NUMBER FORMATS","open-source-fmi.section.fmi-eng-solvers.secondaryLeftKicker":"RESULT RECORD","open-source-fmi.section.fmi-eng-lifecycle.secondaryLeftKicker":"LEGAL STATE","open-source-fmi.section.fmi-eng-events-clocks.secondaryLeftKicker":"EVENT TIMELINE","open-source-fmi.section.fmi-eng-backends.secondaryLeftKicker":"LOCAL PLACEMENT","open-source-fmi.section.fmi-eng-orchestration.secondaryLeftKicker":"CONNECTION GRAPH","open-source-fmi.section.fmi-eng-algebraic-loops.secondaryLeftKicker":"LOOP GROUP","open-source-fmi.section.fmi-eng-distributed.secondaryLeftKicker":"NODE RECORD","open-source-fmi.section.fmi-eng-state-history.secondaryLeftKicker":"SAVED HISTORY","open-source-fmi.section.fmi-eng-twin-bridge.secondaryLeftKicker":"TWIN MAPPING","open-source-fmi.section.fmi-eng-ffi.secondaryLeftKicker":"ABI SURFACE","open-source-fmi.section.fmi-biz-lifecycle.secondaryLeftKicker":"ONE MODEL","open-source-fmi.section.fmi-biz-suppliers.secondaryLeftKicker":"INTAKE GATE","open-source-fmi.section.fmi-biz-cosimulation.secondaryLeftKicker":"SHARED GRAPH","open-source-fmi.section.fmi-biz-resume.secondaryLeftKicker":"SAVED RUN","open-source-fmi.section.fmi-biz-live-twin.secondaryLeftKicker":"LIVE MAPPING","open-source-fmi.section.fmi-biz-conflict-policy.secondaryLeftKicker":"AUTHORITY RULE","open-source-fmi.section.fmi-biz-provenance.secondaryLeftKicker":"TIMELINE RECORD","open-source-fmi.section.fmi-biz-host-fit.secondaryLeftKicker":"FIRST STEP","open-source-fmi.section.fmi-biz-scale.secondaryLeftKicker":"DEPLOYMENT","open-source-fmi.section.fmi-biz-commercial.secondaryLeftKicker":"OWNERSHIP","open-source-fmi.section.fmi-con-model-first.secondaryLeftKicker":"SHARED DESCRIPTION","open-source-fmi.section.fmi-con-many-computers.secondaryLeftKicker":"SAME MODEL","open-source-fmi.section.fmi-con-coupled.secondaryLeftKicker":"VISIBLE CONNECTIONS","open-source-fmi.section.fmi-con-save.secondaryLeftKicker":"SAVED MOMENT","open-source-fmi.section.fmi-con-live.secondaryLeftKicker":"MODEL TO SYSTEM","open-source-fmi.section.fmi-con-disagree.secondaryLeftKicker":"DECISION RECORD","open-source-fmi.section.fmi-con-reopen.secondaryLeftKicker":"SAME PAST","open-source-fmi.90214883b6":"Talk to us","oss-fmi-arithmetic-compare.fa28983085":"Across platforms","oss-fmi-arithmetic-compare.b462790c95":"Results vary by CPU architecture","oss-fmi-arithmetic-compare.1bcc7fc982":"Compared across architectures","oss-fmi-arithmetic-compare.726cc3e286":"Across compilers","oss-fmi-arithmetic-compare.e4898f4b98":"Optimiser changes float order","oss-fmi-arithmetic-compare.ba659aac6a":"Compiler choices made explicit","oss-fmi-arithmetic-compare.ac458e6963":"Math libraries","oss-fmi-arithmetic-compare.53df4c02d0":"libm functions can differ slightly","oss-fmi-arithmetic-compare.4f3c2c20e1":"No platform libm on the hot path","oss-fmi-arithmetic-compare.32c657b423":"Hardware migration","oss-fmi-arithmetic-compare.c15355990c":"Re-validate the whole portfolio","oss-fmi-arithmetic-compare.85432b22d0":"Migration is operational, not numerical","oss-fmi-arithmetic-compare.87025bab20":"Safety case","oss-fmi-arithmetic-compare.be702f13ae":"One case per platform","oss-fmi-arithmetic-compare.8194ef0c5e":"One declared contract across backends","oss-fmi-arithmetic-compare.007256c3f3":"Same FMU, every backend, compared","oss-fmi-arithmetic-compare.15d7136586":"floor swapped, model unchanged","oss-fmi-arithmetic-compare.eb2b21add1":"IEEE 754","oss-fmi-arithmetic-compare.d0f88a0f5a":"Float-based FMI","oss-fmi-arithmetic-compare.502d9b29ec":"Existing implementations rely on floating-point. Results shift across compiler versions,\n            math libraries, and CPU architectures, so the compliance evidence becomes platform-specific.","oss-fmi-arithmetic-compare.fce42136e9":"Fixed-point","oss-fmi-arithmetic-compare.38a040c337":"Dweve FMI","oss-fmi-arithmetic-compare.c579c88eb4":"Fixed-point arithmetic checked against MPFR. The same simulation is compared on each platform under a declared contract.\n            The deployment choice is operational, while the validation scope remains explicit.","oss-fmi-arithmetic-compare.12b298f305":"Swap the arithmetic floor. The model and the safety case stay the same.","oss-fmi-arithmetic-compare.10c4c8496b":"MPFR reference check","oss-fmi-asset-and-model.chrome.path":"Alongside the asset","oss-fmi-asset-and-model.chrome.status":"three measurements in, two predictions out","oss-fmi-asset-and-model.chrome.meta":"one continuing model","oss-fmi-asset-and-model.asset.name":"the real pump","oss-fmi-asset-and-model.asset.note":"built, running, measured","oss-fmi-asset-and-model.model.name":"the model","oss-fmi-asset-and-model.model.note":"the same model from the design test","oss-fmi-asset-and-model.arrow.current.label":"measured current","oss-fmi-asset-and-model.arrow.inlet-pressure.label":"inlet pressure","oss-fmi-asset-and-model.arrow.ambient-temperature.label":"ambient temperature","oss-fmi-asset-and-model.arrow.bearing-temperature.label":"predicted bearing temperature","oss-fmi-asset-and-model.arrow.service-margin.label":"remaining service margin","oss-fmi-asset-and-model.arrow.tags":"source, target, unit and time","oss-fmi-asset-and-model.mode.real-time":"real-time","oss-fmi-asset-and-model.mode.batch":"batch","oss-fmi-asset-and-model.band.left":"every crossing keeps its context","oss-fmi-asset-and-model.band.right":"context travels with the value","oss-fmi-backend-banner.eyebrow":"The execution fabric","oss-fmi-backend-banner.lead":"The hardware changes.","oss-fmi-backend-banner.lead-accent":"The model contract does not.","oss-fmi-backend-banner.paragraphs.0":"A model that begins as a small interactive run may later become a thousand-scenario study, a hardware-in-the-loop workload, a controller-side prediction or one partition of a distributed co-simulation. Those are different execution problems. They should not require different definitions of the system being simulated.","oss-fmi-backend-banner.paragraphs.1":"Dweve FMI keeps the model, state, solver result, diagnostics and provenance behind one backend interface. CPU, GPU, FPGA, edge and distributed execution specialise the work without inventing a second variable model or a second way to save state. Backend parity can therefore be tested directly: same run identity in, final-state and trajectory identity out, or a first divergence named.","oss-fmi-backend-banner.panel.header":"One run identity","oss-fmi-backend-banner.panel.tag":"five execution fabrics","oss-fmi-backend-banner.chips.identity.label":"model and FMU identity","oss-fmi-backend-banner.chips.numerus.label":"Numerus format","oss-fmi-backend-banner.chips.solver.label":"solver and tolerance policy","oss-fmi-backend-banner.chips.clocks.label":"clock and event policy","oss-fmi-backend-banner.chips.state.label":"state and diagnostic contract","oss-fmi-backend-banner.chips.backends.label":"CPU, GPU, FPGA, edge and distributed","oss-fmi-backend-banner.chips.shared":"shared","oss-fmi-backend-banner.chips.backends.marker":"selected per workload","oss-fmi-backend-banner.verdict":"execution moves; the model remains the same engineering object","oss-fmi-backend-banner.footline":"one model contract from a single core to a distributed simulation","oss-fmi-backend-deck.ff221d4752":"CPU","oss-fmi-backend-deck.59dbdd341d":"General engineering, day to day authoring","oss-fmi-backend-deck.24ae02dd90":"A common target for authoring, validation and continuous integration. Use its output as a declared reference when comparing other backends.","oss-fmi-backend-deck.a6a6318544":"GPU","oss-fmi-backend-deck.9a6cc875d8":"Batched runs and large parameter studies","oss-fmi-backend-deck.725ebde71c":"Batched execution for parameter sweeps and Monte Carlo studies. Many runs at once, each compared with the declared CPU reference.","oss-fmi-backend-deck.cef7f9bd36":"FPGA","oss-fmi-backend-deck.2c2f3f770f":"Cycle-tight hardware in the loop scenarios","oss-fmi-backend-deck.fd29cc1af2":"For hardware in the loop where the latency budget is hard. The same FMU runs against real hardware and records output-vector comparisons.","oss-fmi-backend-deck.8440b9eb7d":"Edge","oss-fmi-backend-deck.4dc3c90a3c":"Battery-powered embedded controllers","oss-fmi-backend-deck.2fea6f5c64":"Embedded and edge targets where memory and energy dominate. Runs the same model on a small device under the declared numerical contract.","oss-fmi-backend-deck.bb3d98dfee":"Distributed","oss-fmi-backend-deck.18854c5c57":"Large studies split across a cluster","oss-fmi-backend-deck.c9307c2b8f":"Split a large study across nodes. The replay contract records the distributed run end to end so it can be compared with a single-host run.","oss-fmi-backend-deck.9d8c0969a6":"Same kernel, reference checks across targets","oss-fmi-backend-deck.e9045ea057":"5 backends","oss-fmi-backend-deck.b3776d63ad":"Backends","oss-fmi-backend-deck.6d7ae87f78":"Best for","oss-fmi-backend-deck.528e133c79":"Cross-target","oss-fmi-backend-deck.51ab88da6e":"Reference check","oss-fmi-backend-deck.a7dc6ac385":"output vectors compared","oss-fmi-backend-deck.d8d931a871":"Migrate the target with an explicit validation record. The comparison shows what moves.","oss-fmi-backend-deck.c63f995892":"One deterministic kernel","oss-fmi-backend-deck.aa14ea21a1":"Workstation and CI","oss-fmi-backend-deck.ab2ed5fd39":"Parameter sweeps","oss-fmi-backend-deck.ac43226d23":"Hardware in the loop","oss-fmi-backend-deck.ad43b60f16":"Embedded controllers","oss-fmi-backend-deck.ae1f18cd5b":"Across nodes","oss-fmi-backend-fan.chrome.path":"Execution backends","oss-fmi-backend-fan.chrome.status":"four envelopes match, one divergence named","oss-fmi-backend-fan.chrome.meta":"parity measured, illustrative","oss-fmi-backend-fan.bundle.title":"one run bundle","oss-fmi-backend-fan.bundle.contents.0":"model hash","oss-fmi-backend-fan.bundle.contents.1":"initial state","oss-fmi-backend-fan.bundle.contents.2":"inputs","oss-fmi-backend-fan.bundle.contents.3":"solver policy","oss-fmi-backend-fan.bundle.contents.4":"arithmetic format","oss-fmi-backend-fan.bundle.contents.5":"clocks","oss-fmi-backend-fan.bundle.contents.6":"coupling graph","oss-fmi-backend-fan.selector.name":"backend selector","oss-fmi-backend-fan.paths.cpu.name":"SIMD CPU","oss-fmi-backend-fan.paths.cpu.posture":"single lane, low overhead","oss-fmi-backend-fan.paths.gpu.name":"GPU ensemble","oss-fmi-backend-fan.paths.gpu.posture":"wide batched lanes","oss-fmi-backend-fan.paths.fpga.name":"FPGA pipeline","oss-fmi-backend-fan.paths.fpga.posture":"fixed pipeline, cycle-tight","oss-fmi-backend-fan.paths.edge.name":"Edge controller","oss-fmi-backend-fan.paths.edge.posture":"narrow, bounded buffers","oss-fmi-backend-fan.paths.distributed.name":"Distributed","oss-fmi-backend-fan.paths.distributed.posture":"branched across nodes","oss-fmi-backend-fan.envelope.state-hash":"state hash","oss-fmi-backend-fan.envelope.state-hash-value":"9f2ce1a4","oss-fmi-backend-fan.envelope.trajectory-hash":"trajectory hash","oss-fmi-backend-fan.envelope.trajectory-hash-value":"77bd03c2","oss-fmi-backend-fan.envelope.match":"match","oss-fmi-backend-fan.mismatch.title":"mismatch injected","oss-fmi-backend-fan.mismatch.backend":"backend","oss-fmi-backend-fan.mismatch.state-index":"state index","oss-fmi-backend-fan.mismatch.state-index-value":"41","oss-fmi-backend-fan.mismatch.first-step":"first divergent step","oss-fmi-backend-fan.mismatch.first-step-value":"1,024","oss-fmi-backend-fan.band.text":"Same run identity in, final-state and trajectory identity out.","oss-fmi-backend-fan.band.meta":"parity is measured","oss-fmi-backend-roles.kicker.label":"Four local backends","oss-fmi-backend-roles.kicker.sub":"chosen by workload shape","oss-fmi-backend-roles.tag":"EXECUTION","oss-fmi-backend-roles.rows.cpu.name":"CPU","oss-fmi-backend-roles.rows.cpu.fit":"interactive and general simulation","oss-fmi-backend-roles.rows.cpu.property":"low setup, scalar and SIMD dispatch","oss-fmi-backend-roles.rows.cpu.evidence":"instruction path and trajectory hash","oss-fmi-backend-roles.rows.gpu.name":"GPU","oss-fmi-backend-roles.rows.gpu.fit":"ensembles, sweeps and wide state","oss-fmi-backend-roles.rows.gpu.property":"batched parallel execution","oss-fmi-backend-roles.rows.gpu.evidence":"batch identity and transfer cost","oss-fmi-backend-roles.rows.fpga.name":"FPGA","oss-fmi-backend-roles.rows.fpga.fit":"fixed graphs and real-time loops","oss-fmi-backend-roles.rows.fpga.property":"deterministic pipeline latency","oss-fmi-backend-roles.rows.fpga.evidence":"bitstream and cycle trace","oss-fmi-backend-roles.rows.edge.name":"Edge","oss-fmi-backend-roles.rows.edge.fit":"controllers and constrained devices","oss-fmi-backend-roles.rows.edge.property":"bounded buffers and no_std","oss-fmi-backend-roles.rows.edge.evidence":"memory ceiling and deadline record","oss-fmi-backend-roles.footline.left":"different hardware postures","oss-fmi-backend-roles.footline.right":"one model and state contract","oss-fmi-before-build.kicker.label":"What is tried first","oss-fmi-before-build.kicker.sub":"before physical parts exist","oss-fmi-before-build.tag":"PLAIN","oss-fmi-before-build.labels.asks":"asks","oss-fmi-before-build.labels.found":"found","oss-fmi-before-build.labels.later":"later","oss-fmi-before-build.system.lift.name":"Lift","oss-fmi-before-build.system.lift.asks":"how the car, motor and cable move together","oss-fmi-before-build.system.lift.found":"oscillation or overload","oss-fmi-before-build.system.lift.later":"safer control and sizing","oss-fmi-before-build.system.pump.name":"Pump","oss-fmi-before-build.system.pump.asks":"how pressure and flow respond","oss-fmi-before-build.system.pump.found":"cavitation or unstable control","oss-fmi-before-build.system.pump.later":"operating envelope","oss-fmi-before-build.system.vehicle.name":"Vehicle","oss-fmi-before-build.system.vehicle.asks":"how power, braking and temperature interact","oss-fmi-before-build.system.vehicle.found":"range or thermal limit","oss-fmi-before-build.system.vehicle.later":"system-level trade-offs","oss-fmi-before-build.system.medical-device.name":"Medical device","oss-fmi-before-build.system.medical-device.asks":"how control and delivery behave","oss-fmi-before-build.system.medical-device.found":"timing or dosing fault","oss-fmi-before-build.system.medical-device.later":"repeatable test evidence","oss-fmi-before-build.foot.left":"the model is made early","oss-fmi-before-build.foot.right":"and can remain useful later","oss-fmi-boundary-conversion.chrome.path":"Numerical boundary","oss-fmi-boundary-conversion.chrome.status":"three converted, one refused","oss-fmi-boundary-conversion.chrome.meta":"boundary explicit, illustrative","oss-fmi-boundary-conversion.zones.host":"FMI host","oss-fmi-boundary-conversion.zones.boundary":"conversion boundary","oss-fmi-boundary-conversion.zones.runtime":"runtime","oss-fmi-boundary-conversion.crossings.pressure.incoming-type":"Float64","oss-fmi-boundary-conversion.crossings.pressure.label":"pressure","oss-fmi-boundary-conversion.crossings.pressure.target":"Q31.32","oss-fmi-boundary-conversion.crossings.pressure.scale":"scale 2^-32","oss-fmi-boundary-conversion.crossings.actuator.incoming-type":"Float32","oss-fmi-boundary-conversion.crossings.actuator.label":"actuator position","oss-fmi-boundary-conversion.crossings.actuator.target":"Q16.16","oss-fmi-boundary-conversion.crossings.actuator.scale":"scale 2^-16","oss-fmi-boundary-conversion.crossings.tariff.incoming-type":"Float64","oss-fmi-boundary-conversion.crossings.tariff.label":"tariff, exact in decimal","oss-fmi-boundary-conversion.crossings.tariff.target":"decimal","oss-fmi-boundary-conversion.crossings.tariff.scale":"exact decimal scale","oss-fmi-boundary-conversion.crossings.sensor.incoming-type":"Float64","oss-fmi-boundary-conversion.crossings.sensor.label":"sensor value 74,120.5","oss-fmi-boundary-conversion.crossings.sensor.target":"Q16.16","oss-fmi-boundary-conversion.crossings.sensor.scale":"permitted -32,768 to 32,767.99998","oss-fmi-boundary-conversion.refusal.title":"refused at the boundary","oss-fmi-boundary-conversion.refusal.incoming":"incoming value","oss-fmi-boundary-conversion.refusal.target":"target format","oss-fmi-boundary-conversion.refusal.range":"permitted range","oss-fmi-boundary-conversion.path.label":"one continuous typed path","oss-fmi-boundary-conversion.path.nodes.0":"derivative evaluation","oss-fmi-boundary-conversion.path.nodes.1":"solver stages","oss-fmi-boundary-conversion.path.nodes.2":"residual calculation","oss-fmi-boundary-conversion.path.nodes.3":"state update","oss-fmi-boundary-conversion.path.marker":"Numerus typed","oss-fmi-boundary-conversion.path.note":"no float object appears after the boundary","oss-fmi-boundary-conversion.band.text":"Conversion is explicit, checked and named.","oss-fmi-boundary-conversion.band.meta":"Numerus through the run","oss-fmi-business-backend-banner.eyebrow":"Scale without a rewrite","oss-fmi-business-backend-banner.lead":"Fit hardware to the work.","oss-fmi-business-backend-banner.lead-accent":"Keep the model.","oss-fmi-business-backend-banner.paragraph.one":"An interactive engineering model, a ten-thousand-case sweep, a deterministic hardware-in-the-loop path and a controller-side prediction are not the same workload. Treating them as one hardware problem buys the wrong machine. Treating them as four modelling projects costs the organisation four models of the same system.","oss-fmi-business-backend-banner.paragraph.two":"Dweve FMI separates those decisions. CPU, GPU, FPGA and edge backends specialise local execution. Distributed placement extends the orchestration graph beyond one machine. The model, variables, solver policy, state and diagnostics remain under one contract, so acceleration becomes a deployment choice and not a second source of truth.","oss-fmi-business-backend-banner.panel.header":"One model, several execution postures","oss-fmi-business-backend-banner.panel.tag":"selected per workload","oss-fmi-business-backend-banner.compare.need":"Programme need","oss-fmi-business-backend-banner.compare.backend":"Execution fit","oss-fmi-business-backend-banner.rows.interactive.need":"interactive engineering","oss-fmi-business-backend-banner.rows.interactive.backend":"CPU","oss-fmi-business-backend-banner.rows.sweeps.need":"large sweeps and ensembles","oss-fmi-business-backend-banner.rows.sweeps.backend":"GPU","oss-fmi-business-backend-banner.rows.latency.need":"fixed low-latency graph","oss-fmi-business-backend-banner.rows.latency.backend":"FPGA","oss-fmi-business-backend-banner.rows.constrained.need":"inside constrained equipment","oss-fmi-business-backend-banner.rows.constrained.backend":"edge","oss-fmi-business-backend-banner.rows.distributed.need":"beyond one machine","oss-fmi-business-backend-banner.rows.distributed.backend":"distributed","oss-fmi-business-backend-banner.rows.contract.need":"model and state contract","oss-fmi-business-backend-banner.rows.contract.backend":"unchanged","oss-fmi-business-backend-banner.verdict":"buy the hardware for the workload, not a second modelling programme","oss-fmi-business-backend-banner.footline":"acceleration changes execution economics; continuity protects engineering ownership","oss-fmi-business-backend-matrix.chrome.path":"Execution choices","oss-fmi-business-backend-matrix.chrome.status":"five needs, five backends","oss-fmi-business-backend-matrix.chrome.meta":"sixth column unchanged","oss-fmi-business-backend-matrix.model.name":"one engineering model","oss-fmi-business-backend-matrix.model.note":"the same object in every column","oss-fmi-business-backend-matrix.columns.need":"programme need","oss-fmi-business-backend-matrix.columns.backend":"backend","oss-fmi-business-backend-matrix.columns.consequence":"commercial consequence","oss-fmi-business-backend-matrix.rows.interactive.need":"interactive engineering","oss-fmi-business-backend-matrix.rows.interactive.backend":"CPU","oss-fmi-business-backend-matrix.rows.interactive.consequence":"immediate iteration","oss-fmi-business-backend-matrix.rows.sweeps.need":"large sweeps and ensembles","oss-fmi-business-backend-matrix.rows.sweeps.backend":"GPU","oss-fmi-business-backend-matrix.rows.sweeps.consequence":"shorter sweep time","oss-fmi-business-backend-matrix.rows.latency.need":"fixed low-latency graph","oss-fmi-business-backend-matrix.rows.latency.backend":"FPGA","oss-fmi-business-backend-matrix.rows.latency.consequence":"lower deterministic latency","oss-fmi-business-backend-matrix.rows.constrained.need":"inside constrained equipment","oss-fmi-business-backend-matrix.rows.constrained.backend":"edge","oss-fmi-business-backend-matrix.rows.constrained.consequence":"bounded controller memory","oss-fmi-business-backend-matrix.rows.distributed.need":"beyond one machine","oss-fmi-business-backend-matrix.rows.distributed.backend":"distributed","oss-fmi-business-backend-matrix.rows.distributed.consequence":"distributed capacity","oss-fmi-business-backend-matrix.unchanged.head":"not recreated","oss-fmi-business-backend-matrix.unchanged.equations":"equations","oss-fmi-business-backend-matrix.unchanged.variable-mapping":"variable mapping","oss-fmi-business-backend-matrix.unchanged.state-format":"state format","oss-fmi-business-backend-matrix.unchanged.solver-diagnostics":"solver diagnostics","oss-fmi-business-backend-matrix.unchanged.twin-integration":"Twin integration","oss-fmi-business-backend-matrix.band.text":"hardware follows the workload","oss-fmi-business-backend-matrix.band.meta":"the model stays the programme's","oss-fmi-business-glyph.f94e5c8649":"not many","oss-fmi-business-glyph.a0b9629e9f":"Safety evidence, recorded once","oss-fmi-business-glyph.2dd17ce85e":"REMOVED HERE","oss-fmi-business-glyph.e0d1dc9c8a":"With this","oss-fmi-business-glyph.1d9ee6f0f4":"PAID REPEATEDLY","oss-fmi-business-glyph.829b0d47de":"The old way","oss-fmi-business-glyph.6cc3364a24":"PARITY VERIFIED","oss-fmi-business-glyph.1cc5a7a1e6":"The outcome, before any demo","oss-fmi-business-glyph.79be3d6f0b":"What you get with Dweve FMI","oss-fmi-business-glyph.a2b27a4cb6":"no hosted service in the path","oss-fmi-business-glyph.6b5eb5323e":"Your hardware","oss-fmi-business-glyph.f73856f540":"data stays put","oss-fmi-business-glyph.6af74613cf":"Built in Europe","oss-fmi-business-glyph.5e6c49e5d5":"Remove the runtime; keep the safety case","oss-fmi-business-glyph.3ac1da9055":"Evidence stays with the model","oss-fmi-business-glyph.9f540d3201":"On premise or an EU region","oss-fmi-business-glyph.62c436123e":"Runs on hardware you own","oss-fmi-business-glyph.66a6acbfe4":"Compared on every backend","oss-fmi-business-glyph.973a1ab0f1":"Differences are visible","oss-fmi-business-glyph.83010c9d03":"Validated on declared targets","oss-fmi-business-glyph.cdf65b5b66":"One validation record","oss-fmi-business-glyph.0fdead3fd1":"A roadmap you do not set","oss-fmi-business-glyph.9df6537132":"One vendor, one price","oss-fmi-business-glyph.3971729abf":"A new chip re-validates the portfolio","oss-fmi-business-glyph.fe74954a77":"New hardware restarts it","oss-fmi-business-glyph.109d2c3d54":"Whose result is the right one","oss-fmi-business-glyph.157d1d4cee":"Teams reconciling numbers","oss-fmi-business-glyph.80d91a51a9":"Re-validated for every machine","oss-fmi-business-glyph.ac192b724a":"A safety case per platform","oss-fmi-cadence-banners.executionContract.eyebrow":"Dweve FMI / execution contract","oss-fmi-cadence-banners.executionContract.lead":"The host chooses a solver","oss-fmi-cadence-banners.executionContract.accent":"without changing the model","oss-fmi-cadence-banners.executionContract.body.one":"The FMI 3 package describes variables, capabilities and execution form. Numerus keeps numeric representation explicit, while the solver fabric selects a method that matches the model and task.","oss-fmi-cadence-banners.executionContract.body.two":"Those choices sit around one lifecycle contract. A different solver or backend does not authorise a different variable identity, clock rule or state transition.","oss-fmi-cadence-banners.executionContract.panel":"Run contract receipt","oss-fmi-cadence-banners.executionContract.tag":"BOUND","oss-fmi-cadence-banners.executionContract.item.fmi.label":"FMI 3 model description","oss-fmi-cadence-banners.executionContract.item.fmi.detail":"Variables, interfaces and capabilities are declared.","oss-fmi-cadence-banners.executionContract.item.fmi.status":"READ","oss-fmi-cadence-banners.executionContract.item.numerics.label":"Numeric contract","oss-fmi-cadence-banners.executionContract.item.numerics.detail":"Representation and boundary conversion remain explicit.","oss-fmi-cadence-banners.executionContract.item.numerics.status":"TYPED","oss-fmi-cadence-banners.executionContract.item.solver.label":"Selected solver","oss-fmi-cadence-banners.executionContract.item.solver.detail":"The route is chosen from model and task requirements.","oss-fmi-cadence-banners.executionContract.item.solver.status":"ROUTED","oss-fmi-cadence-banners.executionContract.item.state.label":"Lifecycle state machine","oss-fmi-cadence-banners.executionContract.item.state.detail":"Calls remain valid for the current FMI state.","oss-fmi-cadence-banners.executionContract.item.state.status":"ENFORCED","oss-fmi-cadence-banners.executionContract.verdict":"execution policy can change while the model contract remains recognisable","oss-fmi-cadence-banners.executionContract.footer":"solver choice is explicit policy around one FMI 3 lifecycle","oss-fmi-cadence-banners.graphExecution.eyebrow":"Dweve FMI / coordinated execution","oss-fmi-cadence-banners.graphExecution.lead":"Several FMUs run together","oss-fmi-cadence-banners.graphExecution.accent":"through one explicit graph","oss-fmi-cadence-banners.graphExecution.body.one":"Typed connections produce a dependency graph that identifies parallel work, ordering and algebraic-loop groups. The orchestrator does not hide a cycle inside a generic failed step.","oss-fmi-cadence-banners.graphExecution.body.two":"Each model can use the backend that fits its workload. The graph keeps value movement, loop policy and communication points visible across those placements.","oss-fmi-cadence-banners.graphExecution.panel":"One communication step","oss-fmi-cadence-banners.graphExecution.tag":"COORDINATED","oss-fmi-cadence-banners.graphExecution.item.backend.label":"Choose model backends","oss-fmi-cadence-banners.graphExecution.item.backend.detail":"CPU, GPU, FPGA or edge placement stays per model.","oss-fmi-cadence-banners.graphExecution.item.backend.status":"PLACED","oss-fmi-cadence-banners.graphExecution.item.graph.label":"Build typed dependencies","oss-fmi-cadence-banners.graphExecution.item.graph.detail":"Connections determine execution levels and value routes.","oss-fmi-cadence-banners.graphExecution.item.graph.status":"ORDERED","oss-fmi-cadence-banners.graphExecution.item.loop.label":"Resolve loop groups","oss-fmi-cadence-banners.graphExecution.item.loop.detail":"Cycles go to an approved loop solver with named operands.","oss-fmi-cadence-banners.graphExecution.item.loop.status":"SOLVED","oss-fmi-cadence-banners.graphExecution.item.step.label":"Commit the step","oss-fmi-cadence-banners.graphExecution.item.step.detail":"Model state and diagnostics advance together.","oss-fmi-cadence-banners.graphExecution.item.step.status":"ADVANCED","oss-fmi-cadence-banners.graphExecution.verdict":"placement varies by model; orchestration remains one reviewable contract","oss-fmi-cadence-banners.graphExecution.footer":"the dependency graph keeps parallel work and cycles attributable","oss-fmi-cadence-banners.continuity.eyebrow":"Dweve FMI / state continuity","oss-fmi-cadence-banners.continuity.lead":"Move the run","oss-fmi-cadence-banners.continuity.accent":"without losing how it reached this state","oss-fmi-cadence-banners.continuity.body.one":"Distributed placement, checkpointing and the Twin bridge all depend on complete state. Visible outputs alone cannot restore solver history, clocks, modes or boundary context.","oss-fmi-cadence-banners.continuity.body.two":"A compatible worker can continue from the saved point, and the operational bridge can retain the same variable identity. The execution context changes without creating an unrelated model history.","oss-fmi-cadence-banners.continuity.panel":"Continuity inventory","oss-fmi-cadence-banners.continuity.tag":"COMPLETE STATE","oss-fmi-cadence-banners.continuity.item.placement.label":"Placement record","oss-fmi-cadence-banners.continuity.item.placement.detail":"The worker and selected backend remain attributable.","oss-fmi-cadence-banners.continuity.item.placement.status":"KNOWN","oss-fmi-cadence-banners.continuity.item.checkpoint.label":"Runtime checkpoint","oss-fmi-cadence-banners.continuity.item.checkpoint.detail":"Model, solver and orchestration state are retained.","oss-fmi-cadence-banners.continuity.item.checkpoint.status":"SAVED","oss-fmi-cadence-banners.continuity.item.clock.label":"Clock and event context","oss-fmi-cadence-banners.continuity.item.clock.detail":"The restored run resumes at the same logical moment.","oss-fmi-cadence-banners.continuity.item.clock.status":"ALIGNED","oss-fmi-cadence-banners.continuity.item.bridge.label":"Twin mapping","oss-fmi-cadence-banners.continuity.item.bridge.detail":"Operational values keep their route to the model.","oss-fmi-cadence-banners.continuity.item.bridge.status":"CONNECTED","oss-fmi-cadence-banners.continuity.verdict":"a run can move from process to process and from study to operation as one history","oss-fmi-cadence-banners.continuity.footer":"complete state makes relocation, replay and operational continuity possible","oss-fmi-cadence-banners.programmeContinuity.eyebrow":"Dweve FMI / programme continuity","oss-fmi-cadence-banners.programmeContinuity.lead":"An interruption costs","oss-fmi-cadence-banners.programmeContinuity.accent":"only the work since the last checkpoint","oss-fmi-cadence-banners.programmeContinuity.body.one":"A long study can survive an ordinary host failure because its checkpoint contains the runtime state needed to continue. The programme chooses the cadence and therefore the maximum work at risk.","oss-fmi-cadence-banners.programmeContinuity.body.two":"The same saved state can start a scenario branch or continue beside the operating asset through Twin. One retained model moves from analysis into operation without a fresh, disconnected representation.","oss-fmi-cadence-banners.programmeContinuity.panel":"From study to operation","oss-fmi-cadence-banners.programmeContinuity.tag":"CONTINUOUS","oss-fmi-cadence-banners.programmeContinuity.item.run.label":"Advance the study","oss-fmi-cadence-banners.programmeContinuity.item.run.detail":"The run accumulates solver and model state.","oss-fmi-cadence-banners.programmeContinuity.item.run.status":"RUNNING","oss-fmi-cadence-banners.programmeContinuity.item.save.label":"Write a complete checkpoint","oss-fmi-cadence-banners.programmeContinuity.item.save.detail":"Cadence states how much work an interruption can lose.","oss-fmi-cadence-banners.programmeContinuity.item.save.status":"SAVED","oss-fmi-cadence-banners.programmeContinuity.item.restore.label":"Resume or branch","oss-fmi-cadence-banners.programmeContinuity.item.restore.detail":"A compatible worker continues from the selected moment.","oss-fmi-cadence-banners.programmeContinuity.item.restore.status":"RESTORED","oss-fmi-cadence-banners.programmeContinuity.item.operate.label":"Connect the live asset","oss-fmi-cadence-banners.programmeContinuity.item.operate.detail":"Twin mappings preserve variable identity and transformations.","oss-fmi-cadence-banners.programmeContinuity.item.operate.status":"LIVE","oss-fmi-cadence-banners.programmeContinuity.verdict":"the model remains an owned programme asset after the original study ends","oss-fmi-cadence-banners.programmeContinuity.footer":"checkpoint cadence turns infrastructure failure into a bounded cost","oss-fmi-cadence-banners.visibleHistory.eyebrow":"Dweve FMI / a history you can revisit","oss-fmi-cadence-banners.visibleHistory.lead":"When two values differ","oss-fmi-cadence-banners.visibleHistory.accent":"the difference stays visible","oss-fmi-cadence-banners.visibleHistory.body.one":"A saved model state and a later measurement can both be legitimate. Keeping both lets you ask whether the model was wrong, the sensor was stale or the operating condition changed.","oss-fmi-cadence-banners.visibleHistory.body.two":"The rule that settles the current value is recorded separately from the values themselves. You can reopen the earlier moment and see what was known then and what changed later.","oss-fmi-cadence-banners.visibleHistory.panel":"One preserved disagreement","oss-fmi-cadence-banners.visibleHistory.tag":"KEPT","oss-fmi-cadence-banners.visibleHistory.item.save.label":"Saved model moment","oss-fmi-cadence-banners.visibleHistory.item.save.detail":"The predicted state and its context remain available.","oss-fmi-cadence-banners.visibleHistory.item.save.status":"4.10 BAR","oss-fmi-cadence-banners.visibleHistory.item.measure.label":"Measured operating value","oss-fmi-cadence-banners.visibleHistory.item.measure.detail":"The asset reports its value through the Twin mapping.","oss-fmi-cadence-banners.visibleHistory.item.measure.status":"4.32 BAR","oss-fmi-cadence-banners.visibleHistory.item.difference.label":"Difference retained","oss-fmi-cadence-banners.visibleHistory.item.difference.detail":"Neither value silently overwrites the other.","oss-fmi-cadence-banners.visibleHistory.item.difference.status":"0.22 BAR","oss-fmi-cadence-banners.visibleHistory.item.record.label":"Decision recorded","oss-fmi-cadence-banners.visibleHistory.item.record.detail":"The chosen authority and reason remain in the history.","oss-fmi-cadence-banners.visibleHistory.item.record.status":"ATTRIBUTED","oss-fmi-cadence-banners.visibleHistory.verdict":"you can see both values, the chosen rule and the person or policy behind it","oss-fmi-cadence-banners.visibleHistory.footer":"the current answer does not erase the earlier evidence","oss-fmi-capability-board.24868df96c":"Built on Numerus fixed-point arithmetic","oss-fmi-capability-board.851a5c9e94":"One kernel. One declared contract. Every backend.","oss-fmi-capability-board.137fca4f24":"Profiles, backends, and oracle checks","oss-fmi-capability-board.b570316ceb":"Model exchange and co-simulation","oss-fmi-capability-board.be9d7073db":"Clock synchronisation","oss-fmi-capability-board.0c15f6df4e":"Co-simulation","oss-fmi-capability-board.c194075c57":"Model exchange","oss-fmi-capability-board.1acef90f01":"Model Exchange integrates with external solvers. Co-Simulation runs standalone. Variable management, clock synchronisation, derivative computation, and event handling are part of the kernel.","oss-fmi-capability-board.87b84e2d54":"Replay from the event log","oss-fmi-capability-board.f820f43bbf":"Fold the log to any state","oss-fmi-capability-board.87d0de61bb":"State changes as events","oss-fmi-capability-board.3a4d4ea459":"The bridge to Twin maps simulation instances to digital twins. State changes are recorded as immutable events, and deterministic replay re-runs a simulation straight from the event log.","oss-fmi-capability-board.3e96eaed81":"Digital twin integration","oss-fmi-capability-board.5b4903b1e6":"Distributed across nodes","oss-fmi-capability-board.8ff03fbc23":"Edge and embedded","oss-fmi-capability-board.c85c254454":"Workstation and cluster","oss-fmi-capability-board.a4b42d9ae5":"The same simulation can run on workstation CPU, GPU, FPGA, edge device and distributed nodes. Compare each target under the declared numerical contract when moving from on-premise to cloud.","oss-fmi-capability-board.2e8e1f1f76":"Hardware freedom","oss-fmi-capability-board.ebd16b2492":"Dec64_6 decimal profile","oss-fmi-capability-board.6c3a1b4103":"Q16.16 embedded profile","oss-fmi-capability-board.d5195fbc8b":"Q31.32 general profile","oss-fmi-capability-board.4e8998eac1":"Every real-valued computation uses fixed-point instead of floating-point. The arithmetic comes from Numerus, where each operation is correctly rounded and verified against the MPFR reference library.","oss-fmi-capability-board.69c32f0fac":"Deterministic arithmetic floor","oss-fmi-capability-board.259c292521":"FPGA hardware in loop","oss-fmi-capability-board.2053df8b65":"GPU batched execution","oss-fmi-capability-board.f962221c72":"x86_64 and AArch64 and RISC-V","oss-fmi-capability-board.857b3db5f3":"Compare simulation outputs across x86_64, AArch64, RISC-V, GPU and FPGA. Compare development results with CI results and retain the platform-specific baseline.","oss-fmi-capability-board.8868970ea5":"Cross-platform comparisons","oss-fmi-checkpoint-branches.chrome.path":"Saved history","oss-fmi-checkpoint-branches.chrome.status":"restored once, branched three ways","oss-fmi-checkpoint-branches.chrome.meta":"parent history intact, illustrative","oss-fmi-checkpoint-branches.spine.label":"one parameter study, checkpoints at regular intervals","oss-fmi-checkpoint-branches.spine.stop":"process stops","oss-fmi-checkpoint-branches.fact.from-checkpoint":"from checkpoint","oss-fmi-checkpoint-branches.fact.repeated":"repeated","oss-fmi-checkpoint-branches.fact.parent-run":"parent run","oss-fmi-checkpoint-branches.fact.split-at":"split at","oss-fmi-checkpoint-branches.fact.changed":"changed","oss-fmi-checkpoint-branches.fact.expected":"expected","oss-fmi-checkpoint-branches.fact.found":"found","oss-fmi-checkpoint-branches.fact.payload":"payload","oss-fmi-checkpoint-branches.reading.restore.kind":"restore","oss-fmi-checkpoint-branches.reading.restore.name":"From checkpoint seven","oss-fmi-checkpoint-branches.reading.restore.prose":"The process stops shortly after checkpoint seven. Restore begins from that checkpoint and repeats only the small gap up to the stop point; the history before it is read back, not recomputed.","oss-fmi-checkpoint-branches.reading.restore.fact.from":"checkpoint 07","oss-fmi-checkpoint-branches.reading.restore.fact.repeated":"only the gap after 07","oss-fmi-checkpoint-branches.reading.restore.fact.parent":"unchanged","oss-fmi-checkpoint-branches.reading.gain.kind":"branch","oss-fmi-checkpoint-branches.reading.gain.name":"Controller gain","oss-fmi-checkpoint-branches.reading.gain.prose":"The first branch leaves checkpoint nine with a changed controller gain. It carries the parent run ID, the checkpoint version and the changed parameter, then keeps its own state history from the split.","oss-fmi-checkpoint-branches.reading.gain.fact.parent":"run study-2049","oss-fmi-checkpoint-branches.reading.gain.fact.split":"checkpoint 09, state v3","oss-fmi-checkpoint-branches.reading.gain.fact.changed":"controller gain 0.42 to 0.55","oss-fmi-checkpoint-branches.reading.ambient.kind":"branch","oss-fmi-checkpoint-branches.reading.ambient.name":"Ambient profile","oss-fmi-checkpoint-branches.reading.ambient.prose":"The second branch leaves the same checkpoint with a different ambient profile. Parent, split version and changed input stay attached, so the branch can be compared against the run it came from.","oss-fmi-checkpoint-branches.reading.ambient.fact.parent":"run study-2049","oss-fmi-checkpoint-branches.reading.ambient.fact.split":"checkpoint 09, state v3","oss-fmi-checkpoint-branches.reading.ambient.fact.changed":"ambient profile B","oss-fmi-checkpoint-branches.reading.reference.kind":"branch","oss-fmi-checkpoint-branches.reading.reference.name":"Unchanged reference","oss-fmi-checkpoint-branches.reading.reference.prose":"The third branch changes nothing. It is the reference the other two are read against, started from the same checkpoint so every difference stays meaningful.","oss-fmi-checkpoint-branches.reading.reference.fact.parent":"run study-2049","oss-fmi-checkpoint-branches.reading.reference.fact.split":"checkpoint 09, state v3","oss-fmi-checkpoint-branches.reading.reference.fact.changed":"nothing, reference branch","oss-fmi-checkpoint-branches.reading.refused.kind":"refused restore","oss-fmi-checkpoint-branches.reading.refused.name":"Incompatible format","oss-fmi-checkpoint-branches.reading.refused.prose":"A fourth restore arrives against an older state format. Restore refuses before decoding the payload and prints the expected and found versions next to each other.","oss-fmi-checkpoint-branches.reading.refused.fact.expected":"state format v3","oss-fmi-checkpoint-branches.reading.refused.fact.found":"state format v1","oss-fmi-checkpoint-branches.reading.refused.fact.payload":"not decoded","oss-fmi-checkpoint-branches.band.left":"the parent spine is never rewritten","oss-fmi-checkpoint-branches.band.right":"one spine, three branches, one refusal","oss-fmi-commercial-posture.kicker.label":"What is yours","oss-fmi-commercial-posture.kicker.sub":"before and after adoption","oss-fmi-commercial-posture.tag":"OWNED","oss-fmi-commercial-posture.asset.models.name":"Models and FMUs","oss-fmi-commercial-posture.asset.models.ownership":"organisation and suppliers","oss-fmi-commercial-posture.asset.models.operational":"portable under FMI 3","oss-fmi-commercial-posture.asset.models.procurement":"no proprietary remodel","oss-fmi-commercial-posture.asset.deployment.name":"Runtime deployment","oss-fmi-commercial-posture.asset.deployment.ownership":"organisation","oss-fmi-commercial-posture.asset.deployment.operational":"own hardware and release schedule","oss-fmi-commercial-posture.asset.deployment.procurement":"no hosted runtime dependency","oss-fmi-commercial-posture.asset.backend.name":"Backend capacity","oss-fmi-commercial-posture.asset.backend.ownership":"chosen per programme","oss-fmi-commercial-posture.asset.backend.operational":"CPU to distributed","oss-fmi-commercial-posture.asset.backend.procurement":"capacity follows the workload","oss-fmi-commercial-posture.asset.history.name":"State and history","oss-fmi-commercial-posture.asset.history.ownership":"organisation","oss-fmi-commercial-posture.asset.history.operational":"checkpoint and Twin provenance","oss-fmi-commercial-posture.asset.history.procurement":"no vendor-held evidence","oss-fmi-commercial-posture.asset.source.name":"Source code rights","oss-fmi-commercial-posture.asset.source.ownership":"Apache-2.0","oss-fmi-commercial-posture.asset.source.operational":"inspect, modify and embed","oss-fmi-commercial-posture.asset.source.procurement":"clear long-term use","oss-fmi-commercial-posture.foot.left":"publication planned for round ten","oss-fmi-commercial-posture.foot.right":"standard models and organisation-owned history","oss-fmi-commercial-stack.chrome.path":"Commercial freedom","oss-fmi-commercial-stack.chrome.status":"what is owned, and what is chosen","oss-fmi-commercial-stack.chrome.meta":"the line, drawn once","oss-fmi-commercial-stack.column.owned.title":"owned","oss-fmi-commercial-stack.column.owned.sub":"remains the organisation’s own","oss-fmi-commercial-stack.column.owned.mark":"org mark","oss-fmi-commercial-stack.column.chosen.title":"chosen","oss-fmi-commercial-stack.column.chosen.sub":"still chosen and bought","oss-fmi-commercial-stack.owned.models.name":"Models and FMUs","oss-fmi-commercial-stack.owned.models.note":"portable under FMI 3","oss-fmi-commercial-stack.owned.deployment.name":"Deployment","oss-fmi-commercial-stack.owned.deployment.note":"own hardware and release schedule","oss-fmi-commercial-stack.owned.backend.name":"Backend capacity","oss-fmi-commercial-stack.owned.backend.note":"CPU to distributed","oss-fmi-commercial-stack.owned.history.name":"Checkpoints and Twin history","oss-fmi-commercial-stack.owned.history.note":"checkpoint and Twin provenance","oss-fmi-commercial-stack.owned.source.name":"Source rights","oss-fmi-commercial-stack.owned.source.note":"Apache-2.0 terms; publishes in round ten","oss-fmi-commercial-stack.runtime.name":"Dweve FMI runtime","oss-fmi-commercial-stack.runtime.note":"the implementation behind every run","oss-fmi-commercial-stack.runtime.side":"left of the line","oss-fmi-commercial-stack.chosen.hardware.name":"Hardware","oss-fmi-commercial-stack.chosen.hardware.note":"capacity follows the workload","oss-fmi-commercial-stack.chosen.tools.name":"Engineering tools","oss-fmi-commercial-stack.chosen.tools.note":"the existing estate stays useful","oss-fmi-commercial-stack.chosen.support.name":"Support","oss-fmi-commercial-stack.chosen.support.note":"purchased for its actual value","oss-fmi-commercial-stack.chosen.managed.name":"Managed operation","oss-fmi-commercial-stack.chosen.managed.note":"an optional layer","oss-fmi-commercial-stack.line.label":"the line","oss-fmi-commercial-stack.band.left":"inspect, build, embed and operate under Apache-2.0 terms","oss-fmi-commercial-stack.band.right":"the runtime sits left of the line","oss-fmi-conflict-choices.kicker.label":"Five named strategies","oss-fmi-conflict-choices.kicker.sub":"selected before the conflict","oss-fmi-conflict-choices.tag":"POLICY","oss-fmi-conflict-choices.strategy.fmu-wins.name":"FMU wins","oss-fmi-conflict-choices.strategy.fmu-wins.fit":"unobserved or model-authoritative value","oss-fmi-conflict-choices.strategy.fmu-wins.survives":"simulation value","oss-fmi-conflict-choices.strategy.fmu-wins.record":"conflict and automatic resolution","oss-fmi-conflict-choices.strategy.twin-wins.name":"Twin wins","oss-fmi-conflict-choices.strategy.twin-wins.fit":"trusted measured input","oss-fmi-conflict-choices.strategy.twin-wins.survives":"operational value","oss-fmi-conflict-choices.strategy.twin-wins.record":"source and measurement","oss-fmi-conflict-choices.strategy.most-recent.name":"Most recent","oss-fmi-conflict-choices.strategy.most-recent.fit":"time-sensitive ordinary state","oss-fmi-conflict-choices.strategy.most-recent.survives":"newer valid value","oss-fmi-conflict-choices.strategy.most-recent.record":"both timestamps","oss-fmi-conflict-choices.strategy.more-specific.name":"More specific","oss-fmi-conflict-choices.strategy.more-specific.fit":"default versus explicit value","oss-fmi-conflict-choices.strategy.more-specific.survives":"richer value","oss-fmi-conflict-choices.strategy.more-specific.record":"specificity rule","oss-fmi-conflict-choices.strategy.manual.name":"Manual","oss-fmi-conflict-choices.strategy.manual.fit":"safety, dispute or uncertainty","oss-fmi-conflict-choices.strategy.manual.survives":"selected value after review","oss-fmi-conflict-choices.strategy.manual.record":"decision maker and reason","oss-fmi-conflict-choices.labels.record":"record","oss-fmi-conflict-choices.labels.survives":"survives","oss-fmi-conflict-choices.foot.left":"the difference remains visible","oss-fmi-conflict-choices.foot.right":"even after one value is selected","oss-fmi-conflict-decision.chrome.path":"Value conflict","oss-fmi-conflict-decision.chrome.status":"two automatic, one manual","oss-fmi-conflict-decision.chrome.meta":"difference not erased, illustrative","oss-fmi-conflict-decision.mapping.ambient.name":"Ambient temperature","oss-fmi-conflict-decision.mapping.ambient.policy":"most recent","oss-fmi-conflict-decision.mapping.ambient.transform":"identity, °C to °C","oss-fmi-conflict-decision.mapping.ambient.outcome":"The newer valid value proceeds automatically.","oss-fmi-conflict-decision.mapping.wear.name":"Derived wear index","oss-fmi-conflict-decision.mapping.wear.policy":"FMU wins","oss-fmi-conflict-decision.mapping.wear.transform":"identity, unitless","oss-fmi-conflict-decision.mapping.wear.outcome":"The simulation value proceeds for a model-authoritative value.","oss-fmi-conflict-decision.mapping.pressure.name":"Discharge pressure","oss-fmi-conflict-decision.mapping.pressure.policy":"manual review","oss-fmi-conflict-decision.mapping.pressure.validity":"held for review","oss-fmi-conflict-decision.mapping.pressure.transform":"bar to bar, identity","oss-fmi-conflict-decision.mapping.pressure.outcome":"Held until a person selects a value and records a reason.","oss-fmi-conflict-decision.labels.simulation":"simulation","oss-fmi-conflict-decision.labels.twin":"twin","oss-fmi-conflict-decision.labels.event":"event","oss-fmi-conflict-decision.labels.processed":"processed","oss-fmi-conflict-decision.labels.valid":"valid","oss-fmi-conflict-decision.labels.transform":"transform","oss-fmi-conflict-decision.decision.link":"the manual case opens its decision card","oss-fmi-conflict-decision.decision.title":"decision card","oss-fmi-conflict-decision.decision.mapping":"discharge pressure","oss-fmi-conflict-decision.decision.rejected":"rejected, kept on the event","oss-fmi-conflict-decision.decision.selected":"selected, proceeds","oss-fmi-conflict-decision.decision.historyLabel":"recent measured values","oss-fmi-conflict-decision.decision.reasonLabel":"reason recorded","oss-fmi-conflict-decision.decision.reason":"Calibrated sensor inside its validity window.","oss-fmi-conflict-decision.decision.retainedLabel":"what stays attached","oss-fmi-conflict-decision.decision.retained":"The rejected 4.10 bar remains attached to the conflict event with both values, the times and the transformation, so the decision stays attributable.","oss-fmi-conflict-decision.band.left":"the rejected value stays on the conflict event","oss-fmi-conflict-decision.band.right":"authority declared per mapping","oss-fmi-consumer-glyph.5b2543d6e1":"It is checked across machines and quietly helps keep things safe.","oss-fmi-consumer-glyph.e08718c37b":"Nothing for you to do.","oss-fmi-consumer-glyph.cf10e31f86":"A safety office","oss-fmi-consumer-glyph.9525ae1781":"Safe","oss-fmi-consumer-glyph.b76aee974c":"Same","oss-fmi-consumer-glyph.e5de4cc907":"A desk at work","oss-fmi-consumer-glyph.39d31d23af":"one answer.","oss-fmi-consumer-glyph.25dc282b5a":"answer","oss-fmi-consumer-glyph.e6a18ff62a":"Two computers,","oss-fmi-consumer-glyph.24852dbab8":"The whole idea","oss-fmi-continuity-questions.chrome.path":"Simulation continuity","oss-fmi-continuity-questions.chrome.status":"answered in the open","oss-fmi-continuity-questions.question.continuity.ask":"What is simulation continuity?","oss-fmi-continuity-questions.question.continuity.answer":"One FMI 3 model that can be authored, solved, coupled, accelerated, deployed, checkpointed, replayed, branched and kept beside the operating asset, without being rebuilt into a different system at every stage.","oss-fmi-continuity-questions.question.disagree.ask":"What happens when the simulation and the real machine disagree?","oss-fmi-continuity-questions.question.disagree.answer":"Dweve FMI keeps both values and applies the rule chosen for that kind of disagreement, rather than quietly replacing one number with the other.","oss-fmi-continuity-questions.question.hardware.ask":"Does the model stay the same when it moves to different hardware?","oss-fmi-continuity-questions.question.hardware.answer":"Yes. The model's names, states and rules stay as they were. Only the way the calculations are carried out changes, from a laptop to a graphics processor, a fixed hardware chip or a small embedded device.","oss-fmi-continuity-questions.readout.text":"These are the three questions this page is built to answer, with every answer visible on the page.","oss-fmi-continuity-questions.band.left":"three questions, every answer in the open","oss-fmi-coordination-ledger.212c7c5017":"Whatever strategy you pick, the replay contract holds. The choice is operational, not numerical.","oss-fmi-coordination-ledger.52f6f304bb":"Honest trade-off","oss-fmi-coordination-ledger.2956ef9ad6":"Determinism","oss-fmi-coordination-ledger.30abe52ced":"How steps coordinate","oss-fmi-coordination-ledger.ce5f880970":"operational, not numerical","oss-fmi-coordination-ledger.820d6cd57d":"Replay contract holds, every strategy","oss-fmi-coordination-ledger.f726019912":"A network round-trip per step boundary.","oss-fmi-coordination-ledger.10e402eb33":"compared end to end","oss-fmi-coordination-ledger.50f123ddf4":"A mesh of FMUs across nodes, libp2p-coordinated.","oss-fmi-coordination-ledger.bb3d98dfee":"Distributed","oss-fmi-coordination-ledger.a7b817d0a6":"More memory, useful for very large models.","oss-fmi-coordination-ledger.99e8bdacad":"compared across the whole tree","oss-fmi-coordination-ledger.0d7c2ed5e4":"A sub-master per FMU group, with a parent master synchronising.","oss-fmi-coordination-ledger.9a6b47e59a":"Hierarchical","oss-fmi-coordination-ledger.ca53ee0533":"More master logic, slightly higher CPU.","oss-fmi-coordination-ledger.d5e6d11d7a":"compared with a hash-pinned schedule","oss-fmi-coordination-ledger.e4b63e5800":"The master adapts the delta per FMU pair.","oss-fmi-coordination-ledger.e2319b498d":"Variable-step","oss-fmi-coordination-ledger.7ac636476b":"The slowest FMU sets the cadence.","oss-fmi-coordination-ledger.8cc4094378":"replay comparison","oss-fmi-coordination-ledger.bb46d06ec8":"Every FMU advances by the same delta in lockstep.","oss-fmi-coordination-ledger.269d849b5f":"Lock-step","oss-fmi-cost-compare.65360b06fe":"The safety case","oss-fmi-cost-compare.3803c05cd2":"Re-validated for each platform, because the numbers can differ between machines.","oss-fmi-cost-compare.28b37b9abd":"Built once. Compare the result on every backend under the declared contract, then carry the validation record.","oss-fmi-cost-compare.3ed133fa23":"Reconciling results","oss-fmi-cost-compare.b896d5087c":"Teams compare numbers that should already match and argue over whose machine is right.","oss-fmi-cost-compare.04e9e0667e":"Results are compared across machines, so any difference has a visible record to reconcile.","oss-fmi-cost-compare.8d73bbbd56":"Changing hardware","oss-fmi-cost-compare.4ea264f022":"New chips or a new cloud region mean re-validating the whole portfolio.","oss-fmi-cost-compare.fcd90115da":"The same model runs unchanged on the hardware you already own. Moving does not restart it.","oss-fmi-cost-compare.fe4cc997d5":"The supplier","oss-fmi-cost-compare.fbdf2f8e83":"Tied to one vendor, one roadmap, and whatever they choose to charge.","oss-fmi-cost-compare.6579802cb4":"Remove the runtime; the model and its validation evidence remain with you.","oss-fmi-cost-compare.a4b2edef2b":"Where data lives","oss-fmi-cost-compare.755196436c":"Work may run on a platform and a region you do not control.","oss-fmi-cost-compare.8dbab5f3ce":"Runs on premise or in an EU region you choose. Your simulation data stays where you put it.","oss-fmi-cost-compare.4690546dd0":"The old way, and this","oss-fmi-cost-compare.cdb52b43e4":"Same simulation work, viewed side by side. The difference is operational, not technical.","oss-fmi-cost-compare.25592eaf85":"Platform-dependent simulation","oss-fmi-cost-compare.20fc818fc7":"Compared on every machine","oss-fmi-cost-compare.34e3db7636":"Prove it once, run it anywhere, and keep control of where it runs.","oss-fmi-cost-compare.10afeddd62":"One reusable safety case","oss-fmi-coupled-plant.chrome.path":"Coupled system","oss-fmi-coupled-plant.chrome.status":"five FMUs, three execution levels","oss-fmi-coupled-plant.chrome.meta":"order derived, illustrative","oss-fmi-coupled-plant.levels.one":"level 1, parallel","oss-fmi-coupled-plant.levels.two":"level 2","oss-fmi-coupled-plant.levels.three":"level 3","oss-fmi-coupled-plant.fmu.controller":"controller","oss-fmi-coupled-plant.fmu.ambient":"ambient model","oss-fmi-coupled-plant.fmu.powerStage":"power stage","oss-fmi-coupled-plant.fmu.motor":"motor","oss-fmi-coupled-plant.fmu.gearbox":"gearbox","oss-fmi-coupled-plant.fmu.load":"load","oss-fmi-coupled-plant.edges.cmd":"u_cmd -> u_in","oss-fmi-coupled-plant.edges.ambient":"t_amb -> t_ext","oss-fmi-coupled-plant.edges.current":"i_out -> i_in","oss-fmi-coupled-plant.edges.speed":"omega -> omega_in","oss-fmi-coupled-plant.edges.torque":"tau -> tau_in","oss-fmi-coupled-plant.edges.feedback":"speed_fb -> speed_meas","oss-fmi-coupled-plant.feedback.note":"feedback edge, no same-step cycle","oss-fmi-coupled-plant.trace.title":"one communication step","oss-fmi-coupled-plant.trace.read":"read outputs","oss-fmi-coupled-plant.trace.transform":"transform units","oss-fmi-coupled-plant.trace.set":"set downstream inputs","oss-fmi-coupled-plant.trace.step":"step eligible FMUs","oss-fmi-coupled-plant.trace.intermediate":"intermediate return","oss-fmi-coupled-plant.trace.confirm":"confirm shared point","oss-fmi-coupled-plant.trace.confirmed":"shared point confirmed","oss-fmi-coupled-plant.stop.title":"second trace, instance behind the master","oss-fmi-coupled-plant.stop.read":"read outputs","oss-fmi-coupled-plant.stop.check":"communication-point check","oss-fmi-coupled-plant.stop.stopped":"step stopped","oss-fmi-coupled-plant.stop.master":"master t 120.0 ms","oss-fmi-coupled-plant.stop.instance":"power-stage-1 t 118.5 ms","oss-fmi-coupled-plant.stop.note":"the step stops with both times and the instance named","oss-fmi-coupled-plant.band.left":"edges carry exact value references","oss-fmi-coupled-plant.band.right":"three levels, one shared time","oss-fmi-design-to-operation.chrome.path":"From design to operation","oss-fmi-design-to-operation.chrome.status":"one model, four operating phases","oss-fmi-design-to-operation.chrome.meta":"history continuous","oss-fmi-design-to-operation.conventional.label":"conventional route","oss-fmi-design-to-operation.conventional.model":"pump model","oss-fmi-design-to-operation.conventional.fat":"factory acceptance","oss-fmi-design-to-operation.conventional.end":"the model disappears here","oss-fmi-design-to-operation.conventional.twin":"a separate Twin project begins","oss-fmi-design-to-operation.continuous.label":"with the Dweve Twin bridge","oss-fmi-design-to-operation.continuous.note":"different data in, different outputs out, per phase","oss-fmi-design-to-operation.continuous.model":"pump model","oss-fmi-design-to-operation.continuous.same":"the same object throughout","oss-fmi-design-to-operation.continuous.provenance":"one provenance band: model version, parameters, mappings, run IDs","oss-fmi-design-to-operation.columns.in":"in","oss-fmi-design-to-operation.columns.out":"out","oss-fmi-design-to-operation.phases.design-study.name":"design study","oss-fmi-design-to-operation.phases.design-study.in":"synthetic loads","oss-fmi-design-to-operation.phases.design-study.out":"design margins","oss-fmi-design-to-operation.phases.factory-acceptance.name":"factory acceptance","oss-fmi-design-to-operation.phases.factory-acceptance.in":"test-rig measurements","oss-fmi-design-to-operation.phases.factory-acceptance.out":"acceptance results","oss-fmi-design-to-operation.phases.commissioning.name":"commissioning","oss-fmi-design-to-operation.phases.commissioning.in":"live sensor values","oss-fmi-design-to-operation.phases.commissioning.out":"predicted bearing temperature","oss-fmi-design-to-operation.phases.live-operation.name":"live operation","oss-fmi-design-to-operation.phases.live-operation.in":"live sensor values","oss-fmi-design-to-operation.phases.live-operation.out":"alternative operating scenarios","oss-fmi-design-to-operation.band.text":"the model stays beside the asset","oss-fmi-design-to-operation.band.meta":"four phases, one history","oss-fmi-distributed-contract.kicker.label":"Across nodes","oss-fmi-distributed-contract.kicker.sub":"what remains coordinated","oss-fmi-distributed-contract.tag":"DISTRIBUTED","oss-fmi-distributed-contract.columns.global":"global contract","oss-fmi-distributed-contract.columns.local":"node-local choice","oss-fmi-distributed-contract.rows.placement.name":"Model placement","oss-fmi-distributed-contract.rows.placement.global":"one orchestration graph","oss-fmi-distributed-contract.rows.placement.local":"backend and worker count","oss-fmi-distributed-contract.rows.placement.diagnostic":"placement trace","oss-fmi-distributed-contract.rows.time.name":"Time","oss-fmi-distributed-contract.rows.time.global":"communication-point progression","oss-fmi-distributed-contract.rows.time.local":"local internal stepping","oss-fmi-distributed-contract.rows.exchange.name":"State exchange","oss-fmi-distributed-contract.rows.exchange.global":"typed boundary values","oss-fmi-distributed-contract.rows.exchange.local":"transport batching","oss-fmi-distributed-contract.rows.exchange.diagnostic":"source, target and sequence","oss-fmi-distributed-contract.rows.checkpoint.name":"Checkpoint","oss-fmi-distributed-contract.rows.checkpoint.global":"consistent run version","oss-fmi-distributed-contract.rows.checkpoint.local":"local snapshot storage","oss-fmi-distributed-contract.rows.checkpoint.diagnostic":"missing or incompatible shard","oss-fmi-distributed-contract.rows.recovery.name":"Recovery","oss-fmi-distributed-contract.rows.recovery.global":"declared retry and redistribution","oss-fmi-distributed-contract.rows.recovery.local":"local restart","oss-fmi-distributed-contract.rows.recovery.diagnostic":"fault and recovered placement","oss-fmi-distributed-contract.footline.left":"different machines underneath","oss-fmi-distributed-contract.footline.right":"one run above them","oss-fmi-distributed-grid.chrome.path":"Coordinated placement","oss-fmi-distributed-grid.chrome.meta":"local backend independent, illustrative","oss-fmi-distributed-grid.nodes.a.backend":"CPU SIMD","oss-fmi-distributed-grid.nodes.b.backend":"GPU","oss-fmi-distributed-grid.nodes.c.backend":"FPGA","oss-fmi-distributed-grid.nodes.d.backend":"edge scalar","oss-fmi-distributed-grid.nodes.e.backend":"CPU","oss-fmi-distributed-grid.nodes.e.tag":"replacement","oss-fmi-distributed-grid.groups.generation":"generation dispatch","oss-fmi-distributed-grid.groups.transmission":"transmission flow","oss-fmi-distributed-grid.groups.demand":"demand ensemble","oss-fmi-distributed-grid.groups.weather":"weather scenarios","oss-fmi-distributed-grid.groups.relays":"protection relays","oss-fmi-distributed-grid.groups.substation":"substation controllers","oss-fmi-distributed-grid.intra.label":"thin, intra-node","oss-fmi-distributed-grid.boundary.title":"cross-node boundary state","oss-fmi-distributed-grid.boundary.note":"thin within a node, heavy across nodes","oss-fmi-distributed-grid.boundary.voltage":"bus_voltage, t 240.0, A -> C","oss-fmi-distributed-grid.boundary.forecast":"load_forecast, t 240.0, B -> A","oss-fmi-distributed-grid.boundary.relay":"relay_state, t 240.0, C -> D","oss-fmi-distributed-grid.step.arrived":"boundary values 3 of 3 arrived","oss-fmi-distributed-grid.step.confirmed":"communication point confirmed","oss-fmi-distributed-grid.step.caption":"the step completes only after the boundary values arrive","oss-fmi-distributed-grid.recovery.title":"recovery trace","oss-fmi-distributed-grid.recovery.checkpoint":"last checkpoint cp-118","oss-fmi-distributed-grid.recovery.affected":"affected groups: demand ensemble, weather scenarios","oss-fmi-distributed-grid.recovery.replacement":"replacement node E takes both groups","oss-fmi-distributed-grid.recovery.resumed":"resumed at t 240.0","oss-fmi-distributed-grid.runband.text":"one run identity, continuous from first placement to resumed run","oss-fmi-distributed-grid.band.left":"placement changes, the run does not","oss-fmi-distributed-grid.band.right":"checkpoint cp-118 holds the version","oss-fmi-domain-grid.7b29b70e4d":"Same model, every environment","oss-fmi-domain-grid.b627eb9aa8":"Where results inform decisions, reproducibility is the whole point.","oss-fmi-domain-grid.7ed0bae386":"7 sectors","oss-fmi-domain-grid.96f36ba15a":"Reproducibility, not a platform asterisk","oss-fmi-domain-grid.452be9b834":"Bridge simulations to digital twins through Twin. State changes record as events and replay deterministically from the log.","oss-fmi-domain-grid.43b3a512f4":"Live state, event-sourced replay","oss-fmi-domain-grid.301a912562":"Digital twins","oss-fmi-domain-grid.b8220fed02":"Simulate chemical processes with fixed-point mass and energy balances. Validate control logic through co-simulation with deterministic batch execution.","oss-fmi-domain-grid.50089d1839":"Process control, PLC co-simulation","oss-fmi-domain-grid.7db3cf5152":"Industrial","oss-fmi-domain-grid.a6348794db":"Reproduce robot arm kinematics and dynamics with stable trajectory planning. Sensor fusion simulation is deterministic across runs.","oss-fmi-domain-grid.00d119d554":"Kinematics, planning, sensor fusion","oss-fmi-domain-grid.d058025dbc":"Robotics","oss-fmi-domain-grid.16f70f5cc1":"Simulate power converters with fixed-point accuracy. Integrate renewable energy systems with deterministic results across deployments.","oss-fmi-domain-grid.940fd43886":"Grid, power converters, renewables","oss-fmi-domain-grid.437bcb1511":"Energy","oss-fmi-domain-grid.19d07d6f78":"Model device performance with deterministic precision, so each run produces evidence under a declared contract.","oss-fmi-domain-grid.8499c64d58":"Device performance, pump dynamics","oss-fmi-domain-grid.a9a24cd153":"Medical","oss-fmi-domain-grid.cfea747b54":"Validate flight control laws with cross-platform comparisons. Pilot-in-the-loop simulation produces deterministic outputs for training scenarios.","oss-fmi-domain-grid.09895ea872":"Flight dynamics, control laws","oss-fmi-domain-grid.e4fdcd4b23":"Aerospace","oss-fmi-domain-grid.f6e82ccb4b":"Model powertrain and chassis systems with results that teams can compare. Hardware-in-the-loop testing on the FPGA backend uses the same model.","oss-fmi-domain-grid.fde91e0c39":"Engine, transmission, brake, suspension","oss-fmi-domain-grid.7ced80c3b5":"Automotive","oss-fmi-drift-trace.2f9d0de86a":"Platform divergence","oss-fmi-drift-trace.cf7363ae8d":"Results differ between development workstations, CI servers, and certification hardware. The safety case must explain and justify every divergence, or it fails. The testing effort multiplies.","oss-fmi-drift-trace.43b95f29db":"N test rigs","oss-fmi-drift-trace.ab090fdc37":"Compiler sensitivity","oss-fmi-drift-trace.ffe67c3a03":"Different compilers apply different optimisation strategies to floating-point operations. A model that validates under one compiler can fail under another, so teams pin specific compiler versions to keep results stable.","oss-fmi-drift-trace.0ad51a0555":"pin version","oss-fmi-drift-trace.dfc7c66b15":"Math library variance","oss-fmi-drift-trace.5cfa74d1d5":"Trigonometric, exponential and logarithmic functions are implemented differently across platforms. A library can produce a small numerical difference, and over millions of steps that can compound into macroscopic divergence.","oss-fmi-drift-trace.b0fcb6e7ff":"small numerical difference","oss-fmi-drift-trace.683c4d3deb":"Hardware lock-in","oss-fmi-drift-trace.3ade9befbd":"Once a workflow is validated on one processor architecture, moving to another risks divergence. Teams cannot upgrade hardware or adopt cloud instances without re-validating the entire simulation portfolio.","oss-fmi-drift-trace.38cf5ff2aa":"Divergence observed","oss-fmi-drift-trace.0afe35aaf1":"integration step axis","oss-fmi-drift-trace.4a8b7caaec":"Two floating-point trajectories diverge over integration steps while the fixed-point line stays flat.","oss-fmi-drift-trace.a965e3bd60":"output drift","oss-fmi-drift-trace.00a9659bb1":"float, machine A","oss-fmi-drift-trace.3bc221a13a":"float, machine B","oss-fmi-drift-trace.8fe6274cac":"fixed-point, every machine","oss-fmi-drift-trace.24eca8c29c":"IEEE 754 float, drifts per platform","oss-fmi-drift-trace.d93d54c0e1":"Fixed-point, reference checks across platforms","oss-fmi-drift-trace.f327983d4d":"Variance is real. The cost of justifying it is hidden.","oss-fmi-due-diligence.ae2e35dce0":"EVIDENCE BEFORE ADOPTION","oss-fmi-due-diligence.fcfc47439a":"Every operating claim points to a validation step","oss-fmi-due-diligence.f255e17b28":"Evidence","oss-fmi-due-diligence.98d10f4061":"Six operating claims and the evidence a buyer can review before deciding where FMI belongs","oss-fmi-due-diligence.87b284e78b":"The validation record","oss-fmi-due-diligence.6b5eb5323e":"Same model, declared comparison","oss-fmi-due-diligence.8f87893871":"EVIDENCE READY","oss-fmi-due-diligence.09a3ecefa2":"Adopt it only where the parity contract holds on your intended targets.","oss-fmi-due-diligence.a26b9b7477":"Decide","oss-fmi-due-diligence.72677028b4":"Try","oss-fmi-due-diligence.6caaf4dc8a":"Run the example on your own machines and compare the results.","oss-fmi-due-diligence.b59f1b3c91":"Review the result contract, target matrix and MPFR-backed validation method.","oss-fmi-due-diligence.b8db515e7a":"Look","oss-fmi-due-diligence.6f4215c47a":"Remove the runtime; the model and its validation record remain with you.","oss-fmi-due-diligence.341d869825":"The exit path is clean","oss-fmi-due-diligence.19288a912b":"It runs on premise or in an EU region you choose, so your work stays inside a border you control.","oss-fmi-due-diligence.bba4a70216":"The data boundary is explicit","oss-fmi-due-diligence.dcb593c380":"It runs on a normal workstation, a cluster, or specialist hardware. No special machine needed.","oss-fmi-due-diligence.92b8e80603":"It runs on hardware you own","oss-fmi-due-diligence.2b47482392":"Run the damped oscillator example on two machines and compare the output under the declared contract.","oss-fmi-due-diligence.a6e0302005":"Results compared across machines","oss-fmi-due-diligence.2cfe1cbd3b":"Compare every backend with the MPFR oracle and record any divergence.","oss-fmi-due-diligence.02cd9dec86":"The validation oracle is independent","oss-fmi-due-diligence.87cd15c1c6":"Run the same model on supported targets and compare the output vectors.","oss-fmi-due-diligence.6b99e29725":"The result contract holds","oss-fmi-eng-close-banner.eyebrow":"The whole argument","oss-fmi-eng-close-banner.lead":"Define it once.","oss-fmi-eng-close-banner.accent":"Keep it across every run.","oss-fmi-eng-close-banner.paragraph.one":"The FMI 3 model begins as typed variables, dependencies, equations, states, clocks and capabilities. Numerus gives real-valued computation one deterministic language. The solver fabric gives ODE, DAE, SDE, nonlinear and coupled systems the route they require. The orchestration graph turns several FMUs into one coordinated simulation. The backend layer carries the run from CPU to GPU, FPGA, edge or distributed execution.","oss-fmi-eng-close-banner.paragraph.two":"State does not disappear at process exit. It can be checkpointed, restored, replayed and branched. The Twin bridge lets the same model continue beside the operating asset, with every crossing, conflict and resolution retained as provenance. Existing hosts still see the complete FMI 3 C function table. The implementation language, solver, backend and deployment may change. The model remains the same engineering object.","oss-fmi-eng-close-banner.panel.header":"One continuous model system","oss-fmi-eng-close-banner.panel.tag":"FMI 3","oss-fmi-eng-close-banner.chip.model.label":"model and types","oss-fmi-eng-close-banner.chip.model.status":"retained","oss-fmi-eng-close-banner.chip.solver.label":"solver route","oss-fmi-eng-close-banner.chip.solver.status":"declared","oss-fmi-eng-close-banner.chip.backend.label":"backend","oss-fmi-eng-close-banner.chip.backend.status":"selected","oss-fmi-eng-close-banner.chip.graph.label":"coupling graph","oss-fmi-eng-close-banner.chip.graph.status":"explicit","oss-fmi-eng-close-banner.chip.state.label":"state and history","oss-fmi-eng-close-banner.chip.state.status":"persistent","oss-fmi-eng-close-banner.chip.twin.label":"Twin mapping","oss-fmi-eng-close-banner.chip.twin.status":"bidirectional","oss-fmi-eng-close-banner.chip.abi.label":"host ABI","oss-fmi-eng-close-banner.chip.abi.status":"standard","oss-fmi-eng-close-banner.verdict":"the run can move without losing what it is","oss-fmi-eng-close-banner.footline":"Rust runs it; FMI 3 carries it; Twin keeps it alive","oss-fmi-event-clock-rail.chrome.path":"Events","oss-fmi-event-clock-rail.chrome.status":"event located, partition activated, step returned","oss-fmi-event-clock-rail.chrome.meta":"one ordered timeline, illustrative","oss-fmi-event-clock-rail.rail.aria":"A forty-millisecond simulation rail with a continuous curve, two periodic clocks, one triggered clock and three partitions","oss-fmi-event-clock-rail.axis.start":"0 ms","oss-fmi-event-clock-rail.axis.end":"40 ms","oss-fmi-event-clock-rail.axis.requested":"requested 40 ms","oss-fmi-event-clock-rail.axis.returned":"last successful time 26 ms","oss-fmi-event-clock-rail.lanes.curve":"curve","oss-fmi-event-clock-rail.lanes.event":"event","oss-fmi-event-clock-rail.lanes.clock-a":"clock A","oss-fmi-event-clock-rail.lanes.clock-b":"clock B","oss-fmi-event-clock-rail.lanes.triggered":"triggered","oss-fmi-event-clock-rail.lanes.partitions":"partitions","oss-fmi-event-clock-rail.marks.bracketed":"bracketed","oss-fmi-event-clock-rail.marks.narrowed":"narrowed","oss-fmi-event-clock-rail.marks.located":"root located at 23.5 ms","oss-fmi-event-clock-rail.marks.intermediate":"intermediate update","oss-fmi-event-clock-rail.marks.event-mode":"event mode","oss-fmi-event-clock-rail.marks.iteration":"discrete iteration, two rounds","oss-fmi-event-clock-rail.marks.resume":"resume continuous execution","oss-fmi-event-clock-rail.marks.tick":"tick activates sampling partition","oss-fmi-event-clock-rail.marks.triggered":"fires on the located event","oss-fmi-event-clock-rail.partitions.one":"partition one","oss-fmi-event-clock-rail.partitions.sampling":"sampling partition","oss-fmi-event-clock-rail.partitions.three":"partition three","oss-fmi-event-clock-rail.bound.title":"second case: event-iteration bound reached","oss-fmi-event-clock-rail.bound.unresolved-label":"unresolved indicators","oss-fmi-event-clock-rail.bound.unresolved-value":"two event indicators","oss-fmi-event-clock-rail.bound.rounds-label":"round count","oss-fmi-event-clock-rail.bound.rounds-value":"16","oss-fmi-event-clock-rail.bound.state-label":"state","oss-fmi-event-clock-rail.bound.state-value":"terminal diagnostic","oss-fmi-event-clock-rail.band.text":"The host receives event encountered, early return and last successful time.","oss-fmi-event-clock-rail.band.meta":"one ordered timeline","oss-fmi-everyday-benefits.24ae9cee93":"You will never touch this part yourself. But it quietly makes the\n          machines around you safer, and that is worth knowing.","oss-fmi-everyday-benefits.81ad45c6b9":"Why this is good for everyone","oss-fmi-everyday-benefits.8ccdcadd4e":"Like a tool that fits in the toolbox you already own.","oss-fmi-everyday-benefits.3ae3647667":"It does not need a giant expensive machine. It works on the kind of computer engineers already have on their desk.","oss-fmi-everyday-benefits.0d23c455ac":"It runs on ordinary computers","oss-fmi-everyday-benefits.d12f679d06":"Like one passport that remains valid through the whole journey.","oss-fmi-everyday-benefits.e8011161ea":"Engineers record the validation once, then carry that safety record to the machines they intend to run.","oss-fmi-everyday-benefits.e25d4d7294":"One safety check follows the model","oss-fmi-everyday-benefits.6bec63132e":"Like a smoke alarm that spots trouble before the room fills.","oss-fmi-everyday-benefits.a8b3a521d2":"A high-precision reference catches tiny calculation differences before a machine relies on the result.","oss-fmi-everyday-benefits.e54d54645b":"Small differences are caught early","oss-fmi-everyday-benefits.401c3b1775":"Like a thermometer that reads the same in every room.","oss-fmi-everyday-benefits.c41fd4d8de":"When this is used, the test is compared on each computer so nobody has to guess whose machine differs.","oss-fmi-everyday-benefits.34e5fa45f5":"A declared answer contract","oss-fmi-everyday-scenes.02eba6de45":"You never see any of this. It just helps the people who check these things do their job\n          well.","oss-fmi-everyday-scenes.322d66f63c":"How this helps.","oss-fmi-everyday-scenes.51e31a6a54":"Why the test matters.","oss-fmi-everyday-scenes.4f9c7c54ae":"Deterministic simulation","oss-fmi-everyday-scenes.6c1e147a94":"Tap a picture. Each one is tested on a computer first, and the test is compared across its\n            intended targets.","oss-fmi-everyday-scenes.e3bff7d8b6":"The everyday things it quietly helps keep safe","oss-fmi-everyday-scenes.ed3b6dc1b3":"This keeps the factory test honest and comparable, so the safety evidence is visible in every workshop.","oss-fmi-everyday-scenes.8f81670179":"These machines work next to people. The test that says they are safe needs a declared meaning wherever it runs.","oss-fmi-everyday-scenes.eba075339d":"Robots and machines on a factory line are tested on a computer before they ever move.","oss-fmi-everyday-scenes.607b3d2d49":"The machines that make things","oss-fmi-everyday-scenes.ac456f0817":"This keeps the power test steady and repeatable, so each machine produces a result that can be compared.","oss-fmi-everyday-scenes.61257bb80a":"If the test wobbles between computers, it is harder to be sure the lights stay on and the power stays safe.","oss-fmi-everyday-scenes.1436695807":"The equipment that keeps electricity steady is tested on a computer before it is installed.","oss-fmi-everyday-scenes.036a7543be":"The power that reaches your house","oss-fmi-everyday-scenes.5f72f611d1":"This keeps the pump test explicit and comparable, so the people who check it can trust what they see.","oss-fmi-everyday-scenes.87bbeb97c8":"A pump must give exactly the right amount. A tiny difference in the test could hide a problem that matters for a real person.","oss-fmi-everyday-scenes.27e6e2895c":"A pump that gives someone medicine is tested on a computer long before it reaches a patient.","oss-fmi-everyday-scenes.39fff6f8c3":"A medical pump","oss-fmi-everyday-scenes.59105e1ecd":"This keeps the brake test under one declared contract, so the car can be checked consistently wherever it is tested.","oss-fmi-everyday-scenes.1d9144dfaf":"If the test gives a slightly different answer on a different computer, nobody can be sure the brakes will stop the car the same way every time.","oss-fmi-everyday-scenes.5872a3a9b7":"Before a new car is built, the brakes are tested thousands of times on a computer.","oss-fmi-everyday-scenes.687a0f485d":"The brakes in a car","oss-fmi-everyday-scenes.9242fa3021":"On the road","oss-fmi-everyday-scenes.931806fc24":"In a hospital","oss-fmi-everyday-scenes.94c8ca59d0":"In your home","oss-fmi-everyday-scenes.95043235c4":"In a factory","oss-fmi-existing-estate.chrome.path":"Works with your tools","oss-fmi-existing-estate.chrome.status":"four hosts, one standard surface","oss-fmi-existing-estate.chrome.meta":"Rust adoption not required","oss-fmi-existing-estate.host.authoring":"Authoring environment","oss-fmi-existing-estate.host.master":"Co-simulation master","oss-fmi-existing-estate.host.bench":"Test bench","oss-fmi-existing-estate.host.embedded":"Embedded host","oss-fmi-existing-estate.host.loadingPath":"fmi3* loading path","oss-fmi-existing-estate.fmu.name":"Dweve FMI FMU","oss-fmi-existing-estate.fmu.note":"loaded by all four hosts","oss-fmi-existing-estate.fmu.table":"one exported function table","oss-fmi-existing-estate.implementation.title":"the implementation behind the abi","oss-fmi-existing-estate.implementation.drawnOnce":"drawn once","oss-fmi-existing-estate.implementation.runtime":"Rust runtime","oss-fmi-existing-estate.implementation.numerus":"Numerus","oss-fmi-existing-estate.implementation.solvers":"solver fabric","oss-fmi-existing-estate.implementation.backend":"selected backend","oss-fmi-existing-estate.native.link":"direct Rust API","oss-fmi-existing-estate.native.name":"Native Rust teams","oss-fmi-existing-estate.native.note":"build against the Rust API directly, without the FMI boundary","oss-fmi-existing-estate.band.left":"the implementation is drawn once","oss-fmi-existing-estate.band.right":"standard fmi3* abi","oss-fmi-ffi-families.kicker.label":"What the host reaches","oss-fmi-ffi-families.kicker.sub":"through the standard names","oss-fmi-ffi-families.tag":"INTEROPERABLE","oss-fmi-ffi-families.family.lifecycle.name":"Instantiate and lifecycle","oss-fmi-ffi-families.family.lifecycle.purpose":"create and drive instances","oss-fmi-ffi-families.family.lifecycle.destination":"runtime state machine","oss-fmi-ffi-families.family.lifecycle.validation":"handle, mode and capability","oss-fmi-ffi-families.family.typed-access.name":"Typed get and set","oss-fmi-ffi-families.family.typed-access.purpose":"exchange FMI values","oss-fmi-ffi-families.family.typed-access.destination":"typed storage and Numerus conversion","oss-fmi-ffi-families.family.typed-access.validation":"pointer, length, type and range","oss-fmi-ffi-families.family.fmu-state.name":"FMU state","oss-fmi-ffi-families.family.fmu-state.purpose":"save, restore and serialise","oss-fmi-ffi-families.family.fmu-state.destination":"persistent state layer","oss-fmi-ffi-families.family.fmu-state.validation":"version and payload","oss-fmi-ffi-families.family.derivatives.name":"Derivatives","oss-fmi-ffi-families.family.derivatives.purpose":"directional, adjoint and Jacobian work","oss-fmi-ffi-families.family.derivatives.destination":"solver and derivative services","oss-fmi-ffi-families.family.derivatives.validation":"references and dimensions","oss-fmi-ffi-families.family.clocks.name":"Clocks and partitions","oss-fmi-ffi-families.family.clocks.purpose":"Scheduled Execution","oss-fmi-ffi-families.family.clocks.destination":"clock and partition scheduler","oss-fmi-ffi-families.family.clocks.validation":"activation state","oss-fmi-ffi-families.family.stepping.name":"Do step and updates","oss-fmi-ffi-families.family.stepping.purpose":"Co-Simulation progression","oss-fmi-ffi-families.family.stepping.destination":"solver and event runtime","oss-fmi-ffi-families.family.stepping.validation":"time and step contract","oss-fmi-ffi-families.footline.left":"standard ABI outside","oss-fmi-ffi-families.footline.right":"safe Rust system inside","oss-fmi-four-backends.chrome.path":"Execution backends","oss-fmi-four-backends.chrome.status":"one model, four local postures","oss-fmi-four-backends.chrome.meta":"capabilities explicit, illustrative","oss-fmi-four-backends.model.name":"pump model","oss-fmi-four-backends.model.detail":"one model, one state contract","oss-fmi-four-backends.model.flow":"the same model enters all four","oss-fmi-four-backends.cpu.name":"CPU","oss-fmi-four-backends.cpu.posture":"interactive","oss-fmi-four-backends.cpu.visualLabel":"SIMD lane utilisation","oss-fmi-four-backends.cpu.caption":"scalar tail preserves the ordered contract","oss-fmi-four-backends.cpu.timing":"3.1 ms per step","oss-fmi-four-backends.cpu.capability":"full declared surface","oss-fmi-four-backends.gpu.name":"GPU","oss-fmi-four-backends.gpu.posture":"parallel","oss-fmi-four-backends.gpu.visualLabel":"2,048 parameter variants","oss-fmi-four-backends.gpu.caption":"derivative, state and ensemble work batched","oss-fmi-four-backends.gpu.timing":"512 variants per pass","oss-fmi-four-backends.gpu.capability":"minimum batch declared","oss-fmi-four-backends.fpga.name":"FPGA","oss-fmi-four-backends.fpga.posture":"pipelined","oss-fmi-four-backends.fpga.visualLabel":"derivative graph as a fixed pipeline","oss-fmi-four-backends.fpga.stage1":"state read","oss-fmi-four-backends.fpga.stage2":"derivatives","oss-fmi-four-backends.fpga.stage3":"solver stages","oss-fmi-four-backends.fpga.stage4":"state update","oss-fmi-four-backends.fpga.caption":"42 cycles, deterministic latency","oss-fmi-four-backends.fpga.timing":"200 ns per cycle","oss-fmi-four-backends.fpga.capability":"adaptive stepping not declared","oss-fmi-four-backends.edge.name":"Edge","oss-fmi-four-backends.edge.posture":"embedded","oss-fmi-four-backends.edge.visualLabel":"state, stage buffers and history","oss-fmi-four-backends.edge.segState":"state","oss-fmi-four-backends.edge.segStages":"stage buffers","oss-fmi-four-backends.edge.segHistory":"history","oss-fmi-four-backends.edge.caption":"inside one declared memory bar","oss-fmi-four-backends.edge.timing":"8 ms per step","oss-fmi-four-backends.edge.capability":"adjoint route refused at negotiation","oss-fmi-four-backends.envelope.title":"declared result envelope","oss-fmi-four-backends.envelope.state":"state hash a41f9c","oss-fmi-four-backends.envelope.trajectory":"trajectory 77bd0e","oss-fmi-four-backends.envelope.time":"last successful time t 240.0 ms","oss-fmi-four-backends.envelope.status":"status complete","oss-fmi-four-backends.band.left":"same run identity in, same envelope out","oss-fmi-four-backends.band.right":"timings differ, identity does not","oss-fmi-graph-contract.kicker.label":"The coupling graph","oss-fmi-graph-contract.kicker.sub":"what it fixes before the run","oss-fmi-graph-contract.tag":"ORCHESTRATED","oss-fmi-graph-contract.fields.declares":"declares","oss-fmi-graph-contract.fields.usedFor":"used for","oss-fmi-graph-contract.rows.fmuNode.name":"FMU node","oss-fmi-graph-contract.rows.fmuNode.declares":"instance and capabilities","oss-fmi-graph-contract.rows.fmuNode.usedFor":"placement and scheduling","oss-fmi-graph-contract.rows.fmuNode.failure":"instance unavailable","oss-fmi-graph-contract.rows.connection.name":"Connection","oss-fmi-graph-contract.rows.connection.declares":"source, target and values","oss-fmi-graph-contract.rows.connection.usedFor":"typed propagation","oss-fmi-graph-contract.rows.connection.failure":"type or transformation fault","oss-fmi-graph-contract.rows.executionLevel.name":"Execution level","oss-fmi-graph-contract.rows.executionLevel.declares":"independent ready set","oss-fmi-graph-contract.rows.executionLevel.usedFor":"parallel stepping","oss-fmi-graph-contract.rows.executionLevel.failure":"unsatisfied dependency","oss-fmi-graph-contract.rows.communicationPoint.name":"Communication point","oss-fmi-graph-contract.rows.communicationPoint.declares":"shared requested time","oss-fmi-graph-contract.rows.communicationPoint.usedFor":"step coordination","oss-fmi-graph-contract.rows.communicationPoint.failure":"master and instance times","oss-fmi-graph-contract.rows.delayEdge.name":"Delay edge","oss-fmi-graph-contract.rows.delayEdge.declares":"history length","oss-fmi-graph-contract.rows.delayEdge.usedFor":"causal break in a loop","oss-fmi-graph-contract.rows.delayEdge.failure":"missing history or bound","oss-fmi-graph-contract.footline.left":"the system is a graph","oss-fmi-graph-contract.footline.right":"not an accidental call order","oss-fmi-hero-glyph.6b5eb5323e":"Deterministic simulation","oss-fmi-hero-glyph.1bad8779f2":"Rust 2021","oss-fmi-hero-glyph.7246ae4ea8":"MPFR reference check","oss-fmi-hero-glyph.e1938afdff":"in 0.84s","oss-fmi-hero-glyph.355bcc577d":"Finished","oss-fmi-hero-glyph.0562f32dc5":"Dependencies","oss-fmi-hero-glyph.2180b3e7ce":"Crate","oss-fmi-hero-glyph.1b290eb385":"Cargo.toml","oss-fmi-hero-glyph.51ab88da6e":"Reference check","oss-fmi-hero-glyph.0d3b88ec64":"FMI 3.0","oss-fmi-hero-glyph.8319d9b3b9":"Rust library","oss-fmi-hero-glyph.b2c71c8114":"state = sim.","oss-fmi-hero-glyph.2759edff78":"RK4, exact","oss-fmi-hero-glyph.92fffd917d":"(cfg, model)?;","oss-fmi-hero-glyph.5f97f87756":"Instance","oss-fmi-hero-glyph.4f55d0d971":"sim =","oss-fmi-hero-glyph.dc416e1088":"Step","oss-fmi-hero-glyph.d28f9f9a1a":"EventMode","oss-fmi-hero-glyph.c6f71c4d07":"(name, dir,","oss-fmi-hero-glyph.c8420f84df":"InstanceConfig","oss-fmi-hero-glyph.45bdcb975c":"cfg =","oss-fmi-hero-glyph.26a1a6e193":"x0 = Q31.32","oss-fmi-hero-glyph.73464297b6":", guid);","oss-fmi-hero-glyph.68c2cc7f0c":"Model","oss-fmi-hero-glyph.6a6e8d2c7e":"model =","oss-fmi-hero-glyph.ff29ca29a5":"FixedPointValue","oss-fmi-hero-glyph.837e40c216":"SolverTime","oss-fmi-hero-glyph.db07deea7a":"SolverConfig","oss-fmi-hero-glyph.7d8ea284c6":"VariableMetadata","oss-fmi-host-boundary.chrome.path":"FMI 3 host boundary","oss-fmi-host-boundary.chrome.status":"standard host connected","oss-fmi-host-boundary.chrome.meta":"complete fmi3 surface, illustrative","oss-fmi-host-boundary.endpoint.host.name":"conventional FMI 3 host","oss-fmi-host-boundary.endpoint.host.sub":"function table from the loaded library","oss-fmi-host-boundary.endpoint.rust.name":"Rust runtime services","oss-fmi-host-boundary.endpoint.rust.sub":"one continuous system","oss-fmi-host-boundary.abi.label":"one narrow ABI","oss-fmi-host-boundary.status.ok":"fmi3OK","oss-fmi-host-boundary.status.error":"fmi3Error","oss-fmi-host-boundary.refusal.stopped":"Stopped at the boundary before the value reaches the runtime.","oss-fmi-host-boundary.call.instantiate.symbol":"fmi3InstantiateModelExchange","oss-fmi-host-boundary.call.instantiate.service":"lifecycle","oss-fmi-host-boundary.call.instantiate.diag":"diag fmi.rt.lifecycle","oss-fmi-host-boundary.call.set-float64.symbol":"fmi3SetFloat64","oss-fmi-host-boundary.call.set-float64.service":"typed values","oss-fmi-host-boundary.call.set-float64.diag":"diag fmi.ffi.length-mismatch","oss-fmi-host-boundary.call.set-float64.expected":"expected length 4","oss-fmi-host-boundary.call.set-float64.provided":"provided length 5","oss-fmi-host-boundary.call.do-step.symbol":"fmi3DoStep","oss-fmi-host-boundary.call.do-step.service":"solver and event runtime","oss-fmi-host-boundary.call.do-step.diag":"diag fmi.rt.solver","oss-fmi-host-boundary.call.get-fmu-state.symbol":"fmi3GetFMUState","oss-fmi-host-boundary.call.get-fmu-state.service":"persistent state","oss-fmi-host-boundary.call.get-fmu-state.diag":"diag fmi.rt.state","oss-fmi-host-boundary.call.adjoint.symbol":"fmi3GetAdjointDerivative","oss-fmi-host-boundary.call.adjoint.service":"derivatives","oss-fmi-host-boundary.call.adjoint.diag":"diag fmi.rt.derivatives","oss-fmi-host-boundary.call.partition.symbol":"fmi3ActivateModelPartition","oss-fmi-host-boundary.call.partition.service":"clock scheduler","oss-fmi-host-boundary.call.partition.diag":"diag fmi.rt.clocks","oss-fmi-host-boundary.band.left":"six calls cross, one is stopped at the line","oss-fmi-host-boundary.band.right":"standard statuses, richer diagnostics","oss-fmi-host-fit.kicker.label":"What stays unchanged","oss-fmi-host-fit.kicker.sub":"in the surrounding toolchain","oss-fmi-host-fit.tag":"DROP-IN","oss-fmi-host-fit.asset.authoring.name":"FMI authoring tool","oss-fmi-host-fit.asset.authoring.remains":"modelDescription and packaging workflow","oss-fmi-host-fit.asset.authoring.supplies":"Rust FMU runtime","oss-fmi-host-fit.asset.authoring.adoption":"build and validation","oss-fmi-host-fit.asset.host.name":"Simulation host","oss-fmi-host-fit.asset.host.remains":"dynamic loading and fmi3 calls","oss-fmi-host-fit.asset.host.supplies":"complete function table","oss-fmi-host-fit.asset.host.adoption":"normal FMU intake","oss-fmi-host-fit.asset.bench.name":"Test bench","oss-fmi-host-fit.asset.bench.remains":"conformance and scenario harness","oss-fmi-host-fit.asset.bench.supplies":"deterministic runtime behaviour","oss-fmi-host-fit.asset.bench.adoption":"add model and compare","oss-fmi-host-fit.asset.embedded.name":"Embedded host","oss-fmi-host-fit.asset.embedded.remains":"FMI-compatible caller","oss-fmi-host-fit.asset.embedded.supplies":"edge build and ABI surface","oss-fmi-host-fit.asset.embedded.adoption":"target integration","oss-fmi-host-fit.asset.operations.name":"Operations stack","oss-fmi-host-fit.asset.operations.remains":"existing asset interfaces","oss-fmi-host-fit.asset.operations.supplies":"Twin bridge","oss-fmi-host-fit.asset.operations.adoption":"mapping configuration","oss-fmi-host-fit.labels.adoption":"adoption","oss-fmi-host-fit.foot.left":"the host remains familiar","oss-fmi-host-fit.foot.right":"the implementation improves behind it","oss-fmi-integration-ownership.kicker.label":"What remains attributable","oss-fmi-integration-ownership.kicker.sub":"inside one co-simulation","oss-fmi-integration-ownership.tag":"SYSTEM","oss-fmi-integration-ownership.columns.adds":"Dweve FMI adds","oss-fmi-integration-ownership.rows.fmu-model.artefact":"FMU model","oss-fmi-integration-ownership.rows.fmu-model.owner":"its supplier or team","oss-fmi-integration-ownership.rows.fmu-model.adds":"validated capabilities","oss-fmi-integration-ownership.rows.fmu-model.dispute":"which model produced the value","oss-fmi-integration-ownership.rows.connection.artefact":"Connection","oss-fmi-integration-ownership.rows.connection.owner":"systems integrator","oss-fmi-integration-ownership.rows.connection.adds":"typed mapping and transform","oss-fmi-integration-ownership.rows.connection.dispute":"how the value crossed","oss-fmi-integration-ownership.rows.schedule.artefact":"Schedule","oss-fmi-integration-ownership.rows.schedule.owner":"orchestration policy","oss-fmi-integration-ownership.rows.schedule.adds":"derived execution levels","oss-fmi-integration-ownership.rows.schedule.dispute":"which model ran first","oss-fmi-integration-ownership.rows.loop-policy.artefact":"Loop policy","oss-fmi-integration-ownership.rows.loop-policy.owner":"integration owner","oss-fmi-integration-ownership.rows.loop-policy.adds":"named solver and tolerance","oss-fmi-integration-ownership.rows.loop-policy.dispute":"why convergence was accepted","oss-fmi-integration-ownership.rows.run-result.artefact":"Run result","oss-fmi-integration-ownership.rows.run-result.owner":"programme","oss-fmi-integration-ownership.rows.run-result.adds":"common state and provenance","oss-fmi-integration-ownership.rows.run-result.dispute":"where failure began","oss-fmi-integration-ownership.foot.left":"separate model ownership","oss-fmi-integration-ownership.foot.right":"one inspectable system run","oss-fmi-integration-wiring.2179ed1f91":"Standard FMU in, standard FMU out","oss-fmi-integration-wiring.2766c06b89":"Import, export, orchestrate, and bridge. The kernel stays deterministic at every edge.","oss-fmi-integration-wiring.2abb5c1d0f":"Numerus arithmetic base","oss-fmi-integration-wiring.88a6749a4c":"deterministic kernel","oss-fmi-integration-wiring.38a040c337":"Dweve FMI","oss-fmi-integration-wiring.2fb2df61a7":"standard FMU archive","oss-fmi-integration-wiring.3d220c8235":"Compliant import, round-trip fidelity","oss-fmi-integration-wiring.d3bc8b2f3d":"Bridge to Twin. Simulation state changes are recorded as immutable events, and deterministic replay re-runs a simulation from the event log.","oss-fmi-integration-wiring.34214aaa54":"Bridge","oss-fmi-integration-wiring.044adfd9ed":"STEP 4","oss-fmi-integration-wiring.15429f155e":"Connect multiple FMUs into a system-level simulation. Define the data flow between models, detect algebraic loops automatically, and solve them with fixed-point iteration or Newton-Raphson.","oss-fmi-integration-wiring.a5e7607493":"Orchestrate","oss-fmi-integration-wiring.6be00e946a":"STEP 3","oss-fmi-integration-wiring.88a2e44a4e":"Export results and modified models back to a standard FMU archive for tools that expect floating-point. Binaries, resources, and metadata pack into one archive, with optional code signing.","oss-fmi-integration-wiring.f3e4fadb9e":"Export","oss-fmi-integration-wiring.b2ad896a1c":"STEP 2","oss-fmi-integration-wiring.dde3a2055d":"Import models from any FMI 3.0 compliant tool. Precision converts from floating-point to fixed-point at the import boundary, and the conversion is checked against the arithmetic reference.","oss-fmi-integration-wiring.d6fbc9d2bd":"Import","oss-fmi-integration-wiring.64e02dbe9b":"STEP 1","oss-fmi-interrupted-study.chrome.path":"Resume","oss-fmi-interrupted-study.chrome.status":"twelve minutes repeated, not nine hours","oss-fmi-interrupted-study.chrome.meta":"cadence chosen by programme, illustrative","oss-fmi-interrupted-study.scale.label":"twenty-hour study, hourly checkpoints","oss-fmi-interrupted-study.rail.interruption":"host disappears, 9h12m","oss-fmi-interrupted-study.rail.restart":"restart from zero repeats 9h12m","oss-fmi-interrupted-study.rail.restore":"restore checkpoint nine repeats twelve minutes","oss-fmi-interrupted-study.rail.gate":"compatibility check","oss-fmi-interrupted-study.rail.branch-a":"scenario branch one, different parameters","oss-fmi-interrupted-study.rail.branch-b":"scenario branch two, different parameters","oss-fmi-interrupted-study.readings.interruption.label":"the interruption","oss-fmi-interrupted-study.readings.interruption.title":"The host disappears at 9h12m","oss-fmi-interrupted-study.readings.interruption.prose":"Long studies fail for ordinary reasons: a host is patched, a node is replaced, a queue is pre-empted. Nine hours and twelve minutes into a twenty-hour study, the host disappears. Hourly checkpoints bound what an interruption can cost to the gap since the last saved state.","oss-fmi-interrupted-study.readings.restore.label":"restore checkpoint nine","oss-fmi-interrupted-study.readings.restore.title":"Twelve minutes repeated, not nine hours","oss-fmi-interrupted-study.readings.restore.prose":"Restarting from zero repeats the whole nine hours. Restoring checkpoint nine repeats twelve minutes, after a compatibility check on the saved state, and the study continues with the same history. Both routes are drawn on the same scale, so the recovered time is visible without a percentage.","oss-fmi-interrupted-study.readings.branches.label":"scenario branches","oss-fmi-interrupted-study.readings.branches.title":"Two branches at hour fourteen","oss-fmi-interrupted-study.readings.branches.prose":"Any saved point can become the root of a new scenario. At hour fourteen, two branches leave a later checkpoint and change different parameters. The base study continues untouched, and the saved points remain available for later branches or review.","oss-fmi-interrupted-study.band.text":"every saved point remains available","oss-fmi-interrupted-study.band.meta":"cadence chosen by programme","oss-fmi-lifecycle-costs.kicker.label":"Where models usually split","oss-fmi-lifecycle-costs.kicker.sub":"and what each split creates","oss-fmi-lifecycle-costs.tag":"PROGRAMME","oss-fmi-lifecycle-costs.columns.handover":"handover","oss-fmi-lifecycle-costs.columns.continuity":"continuity","oss-fmi-lifecycle-costs.rows.engineering-analysis.stage":"Engineering analysis","oss-fmi-lifecycle-costs.rows.engineering-analysis.handover":"desktop model","oss-fmi-lifecycle-costs.rows.engineering-analysis.cost":"first model ownership","oss-fmi-lifecycle-costs.rows.engineering-analysis.continuity":"FMI 3 model created","oss-fmi-lifecycle-costs.rows.system-integration.stage":"System integration","oss-fmi-lifecycle-costs.rows.system-integration.handover":"co-simulation wrapper","oss-fmi-lifecycle-costs.rows.system-integration.cost":"second runtime contract","oss-fmi-lifecycle-costs.rows.system-integration.continuity":"same model, orchestrated","oss-fmi-lifecycle-costs.rows.high-performance-study.stage":"High-performance study","oss-fmi-lifecycle-costs.rows.high-performance-study.handover":"accelerated rewrite","oss-fmi-lifecycle-costs.rows.high-performance-study.cost":"new kernels and validation","oss-fmi-lifecycle-costs.rows.high-performance-study.continuity":"backend selection","oss-fmi-lifecycle-costs.rows.embedded-deployment.stage":"Embedded deployment","oss-fmi-lifecycle-costs.rows.embedded-deployment.handover":"smaller reimplementation","oss-fmi-lifecycle-costs.rows.embedded-deployment.cost":"second codebase","oss-fmi-lifecycle-costs.rows.embedded-deployment.continuity":"edge or FPGA backend","oss-fmi-lifecycle-costs.rows.operations.stage":"Operations","oss-fmi-lifecycle-costs.rows.operations.handover":"new twin integration","oss-fmi-lifecycle-costs.rows.operations.cost":"mapping and history project","oss-fmi-lifecycle-costs.rows.operations.continuity":"native Twin bridge","oss-fmi-lifecycle-costs.foot.left":"five stages","oss-fmi-lifecycle-costs.foot.right":"one model contract through them","oss-fmi-lifecycle-gate.kicker.label":"The gate","oss-fmi-lifecycle-gate.kicker.sub":"checked before state changes","oss-fmi-lifecycle-gate.tag":"FMI 3","oss-fmi-lifecycle-gate.columns.refused":"refused","oss-fmi-lifecycle-gate.columns.diagnostic":"diagnostic focus","oss-fmi-lifecycle-gate.phases.instantiated.name":"Instantiated","oss-fmi-lifecycle-gate.phases.instantiated.legal":"configuration and setup","oss-fmi-lifecycle-gate.phases.instantiated.refused":"stepping before initialisation","oss-fmi-lifecycle-gate.phases.instantiated.diagnostic":"operation and current mode","oss-fmi-lifecycle-gate.phases.initialisation.name":"Initialisation","oss-fmi-lifecycle-gate.phases.initialisation.legal":"initial values and parameters","oss-fmi-lifecycle-gate.phases.initialisation.refused":"runtime-only operations","oss-fmi-lifecycle-gate.phases.initialisation.diagnostic":"required mode","oss-fmi-lifecycle-gate.phases.step.name":"Continuous or Step","oss-fmi-lifecycle-gate.phases.step.legal":"integration and communication","oss-fmi-lifecycle-gate.phases.step.refused":"configuration-only mutation","oss-fmi-lifecycle-gate.phases.step.diagnostic":"instance and time","oss-fmi-lifecycle-gate.phases.event.name":"Event","oss-fmi-lifecycle-gate.phases.event.legal":"discrete updates and iteration","oss-fmi-lifecycle-gate.phases.event.refused":"calls from the wrong execution form","oss-fmi-lifecycle-gate.phases.event.diagnostic":"transition and rule","oss-fmi-lifecycle-gate.phases.terminated.name":"Terminated or Error","oss-fmi-lifecycle-gate.phases.terminated.legal":"inspection and disposal","oss-fmi-lifecycle-gate.phases.terminated.refused":"further simulation results","oss-fmi-lifecycle-gate.phases.terminated.diagnostic":"terminal state","oss-fmi-lifecycle-gate.footline.left":"checked before mutation","oss-fmi-lifecycle-gate.footline.right":"so failure stays local","oss-fmi-loop-group.chrome.path":"Loop resolution","oss-fmi-loop-group.chrome.status":"loop solved, alternative refused","oss-fmi-loop-group.chrome.meta":"group diagnostics complete, illustrative","oss-fmi-loop-group.group.title":"strongly connected component","oss-fmi-loop-group.group.outside":"outside the group","oss-fmi-loop-group.nodes.valve":"valve","oss-fmi-loop-group.nodes.pipe":"pipe","oss-fmi-loop-group.nodes.controller":"pressure controller","oss-fmi-loop-group.nodes.reservoir":"reservoir","oss-fmi-loop-group.nodes.delivery":"delivery line","oss-fmi-loop-group.edges.valvePipe":"opening -> drive","oss-fmi-loop-group.edges.pipeController":"pressure -> p_meas","oss-fmi-loop-group.edges.controllerValve":"cmd -> u_cmd","oss-fmi-loop-group.routes.fixedPoint.name":"fixed point","oss-fmi-loop-group.routes.fixedPoint.outcome":"converged","oss-fmi-loop-group.routes.fixedPoint.iterations":"9 iterations","oss-fmi-loop-group.routes.fixedPoint.prose":"Plain substitution settles steadily: each iterate reduces the residual and the group accepts at iteration nine.","oss-fmi-loop-group.routes.relaxed.name":"relaxed fixed point","oss-fmi-loop-group.routes.relaxed.outcome":"converged after relaxation","oss-fmi-loop-group.routes.relaxed.iterations":"14 iterations","oss-fmi-loop-group.routes.relaxed.extra":"relaxation 0.6 from iterate 5","oss-fmi-loop-group.routes.relaxed.prose":"The second parameter set oscillates until a relaxation factor of 0.6 is applied from the fifth iterate; the trend then turns monotone and converges.","oss-fmi-loop-group.routes.newton.name":"Newton","oss-fmi-loop-group.routes.newton.outcome":"converged","oss-fmi-loop-group.routes.newton.iterations":"4 iterations","oss-fmi-loop-group.routes.newton.prose":"With a local Jacobian available, Newton updates reach the same tolerance in four iterations, the fewest of the three routes.","oss-fmi-loop-group.routes.refused.name":"refused at the bound","oss-fmi-loop-group.routes.refused.outcome":"bound reached, group refused","oss-fmi-loop-group.routes.refused.iterations":"50 iterations, cap reached","oss-fmi-loop-group.routes.refused.extra":"record: 3 FMUs, connections and residual history named","oss-fmi-loop-group.routes.refused.prose":"The unsolved case reaches its iteration cap with the residual above tolerance. The record names all three FMUs, the connection values, the route, the norm, the tolerance and the residual history.","oss-fmi-loop-group.chart.title":"residual history","oss-fmi-loop-group.fields.norm":"norm","oss-fmi-loop-group.fields.tolerance":"tolerance","oss-fmi-loop-group.fields.iterations":"iterations","oss-fmi-loop-group.fields.first":"first residual","oss-fmi-loop-group.fields.last":"last residual","oss-fmi-loop-group.values.norm":"scaled L2","oss-fmi-loop-group.values.tolerance":"1e-8","oss-fmi-loop-group.delay.title":"declared delay edge","oss-fmi-loop-group.delay.buffer":"bounded history buffer","oss-fmi-loop-group.delay.slotOld":"h-2","oss-fmi-loop-group.delay.slotMid":"h-1","oss-fmi-loop-group.delay.slotNew":"h0","oss-fmi-loop-group.delay.caption":"delay length declared, the same-step cycle becomes a causal sequence","oss-fmi-loop-group.band.left":"every route carries a norm, a tolerance and a bound","oss-fmi-loop-group.band.right":"converged three ways, refused once","oss-fmi-loop-solvers.kicker.label":"One loop group","oss-fmi-loop-solvers.kicker.sub":"several declared routes","oss-fmi-loop-solvers.tag":"NONLINEAR","oss-fmi-loop-solvers.rows.fixedPoint.name":"Fixed point","oss-fmi-loop-solvers.rows.fixedPoint.when":"the mapping is contractive","oss-fmi-loop-solvers.rows.fixedPoint.record":"iterate values and residual","oss-fmi-loop-solvers.rows.fixedPoint.stopped":"cap and last residual","oss-fmi-loop-solvers.rows.relaxed.name":"Relaxed fixed point","oss-fmi-loop-solvers.rows.relaxed.when":"plain substitution oscillates","oss-fmi-loop-solvers.rows.relaxed.record":"relaxation factor and trend","oss-fmi-loop-solvers.rows.relaxed.stopped":"stagnation or cap","oss-fmi-loop-solvers.rows.newton.name":"Newton","oss-fmi-loop-solvers.rows.newton.when":"a local Jacobian route is viable","oss-fmi-loop-solvers.rows.newton.record":"linear solve and update norm","oss-fmi-loop-solvers.rows.newton.stopped":"singularity or non-convergence","oss-fmi-loop-solvers.rows.delay.name":"Declared delay","oss-fmi-loop-solvers.rows.delay.when":"one-step staleness is acceptable","oss-fmi-loop-solvers.rows.delay.record":"history slot and delay length","oss-fmi-loop-solvers.rows.delay.stopped":"history bound","oss-fmi-loop-solvers.rows.refuse.name":"Refuse","oss-fmi-loop-solvers.rows.refuse.when":"no approved route exists","oss-fmi-loop-solvers.rows.refuse.record":"SCC and connections","oss-fmi-loop-solvers.rows.refuse.stopped":"named group","oss-fmi-loop-solvers.footline.left":"the loop solver is configuration","oss-fmi-loop-solvers.footline.right":"not hidden master behaviour","oss-fmi-mode-sequence.chrome.path":"Lifecycle sequence","oss-fmi-mode-sequence.chrome.status":"refused before state mutation","oss-fmi-mode-sequence.chrome.meta":"lifecycle explicit, illustrative","oss-fmi-mode-sequence.lanes.calls":"calls in","oss-fmi-mode-sequence.lanes.mode":"mode","oss-fmi-mode-sequence.lanes.effects":"state effects","oss-fmi-mode-sequence.modes.instantiated":"instantiated","oss-fmi-mode-sequence.modes.configuration":"configuration","oss-fmi-mode-sequence.modes.initialisation":"initialisation","oss-fmi-mode-sequence.modes.step":"step","oss-fmi-mode-sequence.modes.event":"event","oss-fmi-mode-sequence.modes.terminated":"terminated","oss-fmi-mode-sequence.rows.instantiate.call":"fmi3Instantiate","oss-fmi-mode-sequence.rows.instantiate.effect":"instance created","oss-fmi-mode-sequence.rows.enter-configuration.call":"enter configuration","oss-fmi-mode-sequence.rows.enter-configuration.effect":"setup applied","oss-fmi-mode-sequence.rows.enter-initialisation.call":"enter initialisation","oss-fmi-mode-sequence.rows.enter-initialisation.effect":"initial values bound","oss-fmi-mode-sequence.rows.set-values.call":"set values","oss-fmi-mode-sequence.rows.set-values.effect":"values written","oss-fmi-mode-sequence.rows.exit-initialisation.call":"exit initialisation","oss-fmi-mode-sequence.rows.exit-initialisation.effect":"step mode entered","oss-fmi-mode-sequence.rows.advance.call":"fmi3DoStep","oss-fmi-mode-sequence.rows.advance.effect":"time advanced","oss-fmi-mode-sequence.rows.enter-event.call":"enter event mode","oss-fmi-mode-sequence.rows.enter-event.effect":"event handled","oss-fmi-mode-sequence.rows.update-discrete.call":"update discrete states","oss-fmi-mode-sequence.rows.update-discrete.effect":"discrete states updated","oss-fmi-mode-sequence.rows.return-execution.call":"return to execution","oss-fmi-mode-sequence.rows.return-execution.effect":"execution resumed","oss-fmi-mode-sequence.rows.terminate.call":"fmi3Terminate","oss-fmi-mode-sequence.rows.terminate.effect":"terminal state","oss-fmi-mode-sequence.rows.get-after-terminate.call":"fmi3GetFloat64","oss-fmi-mode-sequence.rows.step-after-terminate.call":"fmi3DoStep","oss-fmi-mode-sequence.refusal.call":"fmi3DoStep","oss-fmi-mode-sequence.refusal.title":"wrong-mode call refused","oss-fmi-mode-sequence.refusal.instance":"instance","oss-fmi-mode-sequence.refusal.instance-value":"pump-controller-2","oss-fmi-mode-sequence.refusal.current":"current mode","oss-fmi-mode-sequence.refusal.required":"required mode","oss-fmi-mode-sequence.refusal.operation":"operation","oss-fmi-mode-sequence.refusal.note":"the call stops at the band; no state effect is drawn","oss-fmi-mode-sequence.late.refused":"refused","oss-fmi-mode-sequence.late.effect":"unchanged terminal state","oss-fmi-mode-sequence.band.text":"The runtime never turns an illegal sequence into a half-mutated instance.","oss-fmi-mode-sequence.band.meta":"terminal states stay terminal","oss-fmi-model-before-machine.chrome.path":"Before the machine","oss-fmi-model-before-machine.chrome.status":"problem found before manufacture","oss-fmi-model-before-machine.chrome.meta":"one continuing model","oss-fmi-model-before-machine.zone.models":"the models, running now","oss-fmi-model-before-machine.zone.future":"the physical pump, later","oss-fmi-model-before-machine.future.note":"drawn faint on purpose: no part exists yet","oss-fmi-model-before-machine.model.controller":"controller","oss-fmi-model-before-machine.model.motor":"motor","oss-fmi-model-before-machine.model.hydraulic":"hydraulic system","oss-fmi-model-before-machine.value.speed":"speed","oss-fmi-model-before-machine.value.command":"command","oss-fmi-model-before-machine.value.flow":"flow","oss-fmi-model-before-machine.value.pressure":"pressure","oss-fmi-model-before-machine.finding.oscillation":"unstable pressure oscillation","oss-fmi-model-before-machine.later.label":"later, the same model","oss-fmi-model-before-machine.later.frame":"whole-system test","oss-fmi-model-before-machine.later.note":"the same object moves in, not recreated and not relabelled","oss-fmi-model-before-machine.band.left":"found as equations, not as equipment","oss-fmi-model-before-machine.band.right":"the same description continues","oss-fmi-model-beside-asset.kicker.label":"What moves each way","oss-fmi-model-beside-asset.kicker.sub":"between asset and model","oss-fmi-model-beside-asset.tag":"PLAIN","oss-fmi-model-beside-asset.labels.kept":"kept with value","oss-fmi-model-beside-asset.direction.asset-to-model.name":"Asset to model","oss-fmi-model-beside-asset.direction.asset-to-model.examples":"sensor readings and operator state","oss-fmi-model-beside-asset.direction.asset-to-model.reason":"update the simulation","oss-fmi-model-beside-asset.direction.asset-to-model.kept":"source and time","oss-fmi-model-beside-asset.direction.model-to-twin.name":"Model to Twin","oss-fmi-model-beside-asset.direction.model-to-twin.examples":"prediction, estimate and scenario result","oss-fmi-model-beside-asset.direction.model-to-twin.reason":"support operations","oss-fmi-model-beside-asset.direction.model-to-twin.kept":"model and run identity","oss-fmi-model-beside-asset.direction.both-ways.name":"Both ways","oss-fmi-model-beside-asset.direction.both-ways.examples":"shared state with conflict policy","oss-fmi-model-beside-asset.direction.both-ways.reason":"keep model and asset aligned","oss-fmi-model-beside-asset.direction.both-ways.kept":"difference and resolution","oss-fmi-model-beside-asset.foot.left":"the machine informs the model","oss-fmi-model-beside-asset.foot.right":"the model informs the machine's record","oss-fmi-moment-fork.chrome.path":"Save and explore","oss-fmi-moment-fork.chrome.status":"one save, two alternatives","oss-fmi-moment-fork.chrome.meta":"same starting moment, illustrative","oss-fmi-moment-fork.lane.original":"the run","oss-fmi-moment-fork.save.title":"the saved moment","oss-fmi-moment-fork.save.part.values":"model values","oss-fmi-moment-fork.save.part.clocks":"clock queue","oss-fmi-moment-fork.save.part.mode":"mode","oss-fmi-moment-fork.save.part.solver":"solver state","oss-fmi-moment-fork.branch.valve.name":"branch: valve limit","oss-fmi-moment-fork.branch.valve.note":"reopened from the save with a different valve limit","oss-fmi-moment-fork.branch.original.name":"the original","oss-fmi-moment-fork.branch.original.note":"continues unchanged between the two branches","oss-fmi-moment-fork.branch.load.name":"branch: load profile","oss-fmi-moment-fork.branch.load.note":"reopened from the same save with a different load profile","oss-fmi-moment-fork.fork.origin":"all three begin from the same marked instant","oss-fmi-moment-fork.refusal.note":"every save names its model and settings, so a file that belongs to another model or format is refused instead of opened","oss-fmi-moment-fork.band.left":"the whole moment is saved","oss-fmi-moment-fork.band.right":"two alternatives, one origin","oss-fmi-numerus-formats.kicker.label":"One numerical contract","oss-fmi-numerus-formats.kicker.sub":"formats chosen by role","oss-fmi-numerus-formats.tag":"DETERMINISTIC","oss-fmi-numerus-formats.columns.controls":"controls","oss-fmi-numerus-formats.columns.failure":"failure shape","oss-fmi-numerus-formats.formats.q31-32.name":"Q31.32","oss-fmi-numerus-formats.formats.q31-32.role":"general simulation","oss-fmi-numerus-formats.formats.q31-32.controls":"state, stages, derivatives and residuals","oss-fmi-numerus-formats.formats.q31-32.failure":"range and conversion fault","oss-fmi-numerus-formats.formats.q16-16.name":"Q16.16","oss-fmi-numerus-formats.formats.q16-16.role":"control and constrained paths","oss-fmi-numerus-formats.formats.q16-16.controls":"smaller state and timing representations","oss-fmi-numerus-formats.formats.q16-16.failure":"declared narrower range","oss-fmi-numerus-formats.formats.decimal.name":"Decimal","oss-fmi-numerus-formats.formats.decimal.role":"exact decimal quantities","oss-fmi-numerus-formats.formats.decimal.controls":"values whose decimal identity matters","oss-fmi-numerus-formats.formats.decimal.failure":"scale or precision fault","oss-fmi-numerus-formats.formats.direct.name":"Direct FMI types","oss-fmi-numerus-formats.formats.direct.role":"integers, Boolean, string, binary, clock","oss-fmi-numerus-formats.formats.direct.controls":"typed storage without numeric coercion","oss-fmi-numerus-formats.formats.direct.failure":"type mismatch","oss-fmi-numerus-formats.footline.left":"FMI at the edge","oss-fmi-numerus-formats.footline.right":"Numerus through the run","oss-fmi-one-model-three-hosts.chrome.path":"FMI 3 model, interface-specific hosts","oss-fmi-one-model-three-hosts.chrome.status":"one or more forms, shared state contract","oss-fmi-one-model-three-hosts.chrome.meta":"declared FMI 3 capabilities","oss-fmi-one-model-three-hosts.model.name":"FMI 3 model contract","oss-fmi-one-model-three-hosts.model.tag":"interface set declared","oss-fmi-one-model-three-hosts.model.blocks.variables.label":"variable table","oss-fmi-one-model-three-hosts.model.blocks.variables.value":"value references, types, dimensions, causality and variability","oss-fmi-one-model-three-hosts.model.blocks.states.label":"state references","oss-fmi-one-model-three-hosts.model.blocks.states.value":"continuous states and their derivatives","oss-fmi-one-model-three-hosts.model.blocks.derivatives.label":"derivative interface","oss-fmi-one-model-three-hosts.model.blocks.derivatives.value":"derivative functions and event indicators","oss-fmi-one-model-three-hosts.model.blocks.clocks.label":"clocks","oss-fmi-one-model-three-hosts.model.blocks.clocks.value":"periodic and triggered clock declarations","oss-fmi-one-model-three-hosts.model.blocks.dependencies.label":"dependencies","oss-fmi-one-model-three-hosts.model.blocks.dependencies.value":"dependency declarations for scheduling","oss-fmi-one-model-three-hosts.paths.model-exchange.name":"Model Exchange","oss-fmi-one-model-three-hosts.paths.model-exchange.driver":"the host owns integration","oss-fmi-one-model-three-hosts.paths.model-exchange.steps.0":"ask continuous states","oss-fmi-one-model-three-hosts.paths.model-exchange.steps.1":"ask derivatives and event indicators","oss-fmi-one-model-three-hosts.paths.model-exchange.steps.2":"advance time","oss-fmi-one-model-three-hosts.paths.model-exchange.steps.3":"write states back","oss-fmi-one-model-three-hosts.paths.model-exchange.readout":"An external solver drives the integration loop: it asks the model for continuous states, derivatives and event indicators, advances time itself and writes the new states back. The host owns integration; the model underneath stays the same object.","oss-fmi-one-model-three-hosts.paths.co-simulation.name":"Co-Simulation","oss-fmi-one-model-three-hosts.paths.co-simulation.driver":"the instance owns the steps","oss-fmi-one-model-three-hosts.paths.co-simulation.steps.0":"communication point","oss-fmi-one-model-three-hosts.paths.co-simulation.steps.1":"requested step","oss-fmi-one-model-three-hosts.paths.co-simulation.steps.2":"intermediate update","oss-fmi-one-model-three-hosts.paths.co-simulation.steps.3":"last successful time","oss-fmi-one-model-three-hosts.paths.co-simulation.readout":"The instance advances itself: the host sets a communication point, the FMU takes the requested step, reports intermediate updates and confirms the last successful time. Early return and input interpolation stay inside the same contract.","oss-fmi-one-model-three-hosts.paths.scheduled-execution.name":"Scheduled Execution","oss-fmi-one-model-three-hosts.paths.scheduled-execution.driver":"clocks carry the schedule","oss-fmi-one-model-three-hosts.paths.scheduled-execution.steps.0":"clock one activates partition one","oss-fmi-one-model-three-hosts.paths.scheduled-execution.steps.1":"clock two activates partition two","oss-fmi-one-model-three-hosts.paths.scheduled-execution.readout":"Two clocks activate two model partitions in dependency order, so the host activates work according to an explicit schedule rather than treating the model as one indivisible step.","oss-fmi-one-model-three-hosts.clocks.then":"then","oss-fmi-one-model-three-hosts.shared.label":"shared underneath","oss-fmi-one-model-three-hosts.shared.fields.0":"instance identity","oss-fmi-one-model-three-hosts.shared.fields.1":"current mode","oss-fmi-one-model-three-hosts.shared.fields.2":"value-reference table","oss-fmi-one-model-three-hosts.shared.fields.3":"FMU-state support","oss-fmi-one-model-three-hosts.shared.fields.4":"diagnostic stream","oss-fmi-one-model-three-hosts.band.text":"An FMI 3 FMU may expose one or more interface types. Where a model supports several forms, the execution form changes who drives the work, not what the model is.","oss-fmi-one-model-three-hosts.band.meta":"declared interface set","oss-fmi-open-ledger.66024296b7":"REUSE THE SAFETY CASE","oss-fmi-open-ledger.52efdfc545":"Prove once on the targets you intend to operate","oss-fmi-open-ledger.ace929d2c6":"Six operating facts tied to evidence instead of supplier promises","oss-fmi-open-ledger.1a5de6c3b8":"The operating contract","oss-fmi-open-ledger.6b5eb5323e":"ONE MODEL","oss-fmi-open-ledger.430276078f":"VERIFIED","oss-fmi-open-ledger.8a1713427e":"Model and validation evidence remain with you","oss-fmi-open-ledger.175909d951":"Exit path","oss-fmi-open-ledger.791a774cba":"On premise or in an EU region you select","oss-fmi-open-ledger.b5caffdb7f":"Data boundary","oss-fmi-open-ledger.6f2a741b3c":"One record travels with the model across targets","oss-fmi-open-ledger.1ef1565eea":"Safety case","oss-fmi-open-ledger.f55535b6f6":"MPFR-backed comparison","oss-fmi-open-ledger.ed878dbf53":"Validation oracle","oss-fmi-open-ledger.ff0c3e45b5":"CPU · GPU · FPGA · edge · distributed","oss-fmi-open-ledger.808c6b72bb":"Deployment range","oss-fmi-open-ledger.26790e0c5c":"Output compared across supported targets","oss-fmi-open-ledger.a38926b6d0":"Result contract","oss-fmi-oracle-harness.a1cd31fff4":"The oracle is the reference. The result is the evidence.","oss-fmi-oracle-harness.023928479a":"GUARDED","oss-fmi-oracle-harness.bd564db5d5":"PASS","oss-fmi-oracle-harness.90c161765a":"oracle: MPFR, 256-bit reference","oss-fmi-oracle-harness.43ad271e8e":"fmi verify","oss-fmi-oracle-harness.7acb688913":"runs on every release tag","oss-fmi-oracle-harness.e4cf896d35":"MPFR oracle attached","oss-fmi-oracle-harness.64b11af5e8":"typed error, named equation","oss-fmi-oracle-harness.217bfd5f1c":"Models that should fail, fail with a typed error that names the offending equation. There is no silent divergence. A configured tolerance that is exceeded stops the run and reports why.","oss-fmi-oracle-harness.662a992ce3":"Failure modes are loud","oss-fmi-oracle-harness.6e4df8a0a7":"replay reproduces state","oss-fmi-oracle-harness.e8afd76f69":"A run recorded as events through the Twin bridge replays from the event log and reconstructs the recorded state. The log, trajectory and representation are compared explicitly.","oss-fmi-oracle-harness.a29f3cb52f":"Deterministic replay","oss-fmi-oracle-harness.a7dc6ac385":"output vectors compared","oss-fmi-oracle-harness.b0a8479737":"The same FMU and the same input run on CPU, GPU, FPGA and edge. Compare output vectors across each target and fail the check loudly when a declared comparison diverges.","oss-fmi-oracle-harness.0216a2ba38":"Cross-backend equivalence","oss-fmi-oracle-harness.934a0d9900":"Compared with reference","oss-fmi-oracle-harness.11289cfcb2":"Every fixed-point operation is compared against the MPFR arbitrary-precision reference. The arithmetic floor comes from Numerus, where each operation is correctly rounded and the comparison records any difference from the reference.","oss-fmi-oracle-harness.c6e929c53a":"Arithmetic against MPFR","oss-fmi-parity-side.a7dc6ac385":"output vectors compared","oss-fmi-parts-together.kicker.label":"Three separate owners","oss-fmi-parts-together.kicker.sub":"one connected test","oss-fmi-parts-together.tag":"PLAIN","oss-fmi-parts-together.labels.supplies":"supplies","oss-fmi-parts-together.labels.receives":"receives","oss-fmi-parts-together.labels.owner":"remains owned by","oss-fmi-parts-together.part.controller.name":"Controller","oss-fmi-parts-together.part.controller.supplies":"command","oss-fmi-parts-together.part.controller.receives":"speed and state","oss-fmi-parts-together.part.controller.owner":"control team","oss-fmi-parts-together.part.power-stage.name":"Power stage","oss-fmi-parts-together.part.power-stage.supplies":"current and voltage","oss-fmi-parts-together.part.power-stage.receives":"command and load","oss-fmi-parts-together.part.power-stage.owner":"electronics supplier","oss-fmi-parts-together.part.motor-and-load.name":"Motor and load","oss-fmi-parts-together.part.motor-and-load.supplies":"speed and torque","oss-fmi-parts-together.part.motor-and-load.receives":"power","oss-fmi-parts-together.part.motor-and-load.owner":"mechanical team","oss-fmi-parts-together.part.dweve-fmi.name":"Dweve FMI","oss-fmi-parts-together.part.dweve-fmi.supplies":"order, exchange and time","oss-fmi-parts-together.part.dweve-fmi.receives":"the three models","oss-fmi-parts-together.part.dweve-fmi.owner":"system integrator","oss-fmi-parts-together.foot.left":"three models stay separate","oss-fmi-parts-together.foot.right":"the test behaves as one system","oss-fmi-past-questions.kicker.label":"Questions the history answers","oss-fmi-past-questions.kicker.sub":"after the event","oss-fmi-past-questions.tag":"PLAIN","oss-fmi-past-questions.labels.source":"from","oss-fmi-past-questions.question.diverge.question":"When did the paths diverge","oss-fmi-past-questions.question.diverge.source":"simulation and Twin state sequence","oss-fmi-past-questions.question.diverge.result":"first different step","oss-fmi-past-questions.question.known.question":"What was known then","oss-fmi-past-questions.question.known.source":"processing-time record","oss-fmi-past-questions.question.known.result":"available measurements and predictions","oss-fmi-past-questions.question.rule.question":"Which rule acted","oss-fmi-past-questions.question.rule.source":"mapping and conflict policy","oss-fmi-past-questions.question.rule.result":"named automatic or manual decision","oss-fmi-past-questions.question.another-choice.question":"What if another choice was made","oss-fmi-past-questions.question.another-choice.source":"checkpoint and branch","oss-fmi-past-questions.question.another-choice.result":"typed scenario difference","oss-fmi-past-questions.foot.left":"the past is not a picture","oss-fmi-past-questions.foot.right":"it is a state that can be reopened","oss-fmi-places-to-run.kicker.label":"Five places","oss-fmi-places-to-run.kicker.sub":"one reason for each","oss-fmi-places-to-run.tag":"PLAIN","oss-fmi-places-to-run.labels.changes":"changes","oss-fmi-places-to-run.labels.remains":"remains","oss-fmi-places-to-run.place.ordinary-processor.name":"Ordinary processor","oss-fmi-places-to-run.place.ordinary-processor.why":"interactive engineering","oss-fmi-places-to-run.place.ordinary-processor.changes":"speed and scale","oss-fmi-places-to-run.place.ordinary-processor.remains":"model and state","oss-fmi-places-to-run.place.graphics-processor.name":"Graphics processor","oss-fmi-places-to-run.place.graphics-processor.why":"many variations together","oss-fmi-places-to-run.place.graphics-processor.changes":"parallel batch","oss-fmi-places-to-run.place.graphics-processor.remains":"questions and results","oss-fmi-places-to-run.place.dedicated-chip.name":"Dedicated chip","oss-fmi-places-to-run.place.dedicated-chip.why":"very low predictable delay","oss-fmi-places-to-run.place.dedicated-chip.changes":"fixed hardware pipeline","oss-fmi-places-to-run.place.dedicated-chip.remains":"computation graph","oss-fmi-places-to-run.place.small-controller.name":"Small controller","oss-fmi-places-to-run.place.small-controller.why":"run beside the equipment","oss-fmi-places-to-run.place.small-controller.changes":"memory and power limits","oss-fmi-places-to-run.place.small-controller.remains":"model contract","oss-fmi-places-to-run.place.several-machines.name":"Several machines","oss-fmi-places-to-run.place.several-machines.why":"very large system","oss-fmi-places-to-run.place.several-machines.changes":"placement and messages","oss-fmi-places-to-run.place.several-machines.remains":"one coordinated run","oss-fmi-places-to-run.foot.left":"different machines","oss-fmi-places-to-run.foot.right":"not different descriptions of the system","oss-fmi-plain-conflict.kicker.label":"One disagreement","oss-fmi-plain-conflict.kicker.sub":"what remains afterwards","oss-fmi-plain-conflict.tag":"PLAIN","oss-fmi-plain-conflict.part.model-value.name":"Model value","oss-fmi-plain-conflict.part.model-value.record":"4.10 bar, model and run named","oss-fmi-plain-conflict.part.model-value.why":"the prediction remains available","oss-fmi-plain-conflict.part.measured-value.name":"Measured value","oss-fmi-plain-conflict.part.measured-value.record":"4.32 bar, sensor and time named","oss-fmi-plain-conflict.part.measured-value.why":"the observation remains available","oss-fmi-plain-conflict.part.policy.name":"Policy","oss-fmi-plain-conflict.part.policy.record":"manual for this pressure","oss-fmi-plain-conflict.part.policy.why":"the rule was already chosen","oss-fmi-plain-conflict.part.decision.name":"Decision","oss-fmi-plain-conflict.part.decision.record":"measurement used, operator named","oss-fmi-plain-conflict.part.decision.why":"the next state is explainable","oss-fmi-plain-conflict.foot.left":"one value continues","oss-fmi-plain-conflict.foot.right":"both values remain in the history","oss-fmi-plain-explainer.032861b607":"A declared comparison on every computer. That is the whole idea.","oss-fmi-plain-explainer.d4308b34b3":"Think of it this way.","oss-fmi-plain-explainer.ff0ebf3f46":"Read it from the top. Each step is one simple idea, with an everyday example.","oss-fmi-plain-explainer.1b4b41d590":"What is this, in plain words","oss-fmi-plain-explainer.f0cf487df2":"It is like a photo of a moment. Everyone who looks at it sees the same thing.","oss-fmi-plain-explainer.8b6d62d0a9":"Because the comparison is explicit, the people who sign off on safety can trust the record. They can see whether a different machine produced something else.","oss-fmi-plain-explainer.c92604aae6":"So the people checking safety can trust it","oss-fmi-plain-explainer.54994b4287":"It is like a good ruler. It measures the same whether you use it at home or at the workshop.","oss-fmi-plain-explainer.af4135e1aa":"Dweve FMI is the careful part underneath that makes the comparison explicit on every computer. The test you run at your desk can be compared with the test the safety team runs.","oss-fmi-plain-explainer.8751a16daa":"This makes differences visible everywhere","oss-fmi-plain-explainer.27d689b53d":"It is like two clocks that are each a few seconds off, until you need them to ring at exactly the same time.","oss-fmi-plain-explainer.0744e0857c":"The strange part is that the same test, run on two different computers, can come out a tiny bit different. Usually it does not matter. For a brake or a heart pump, even a tiny difference matters a lot.","oss-fmi-plain-explainer.452804de43":"Different computers can give slightly different answers","oss-fmi-plain-explainer.d6cbf23c04":"It is like checking a recipe in your head before you turn the oven on.","oss-fmi-plain-explainer.5c75c7b5b0":"Before a car, a plane, or a medical pump is built, engineers try it out on a computer first. They run a pretend version of it, over and over, to make sure it is safe.","oss-fmi-plain-explainer.4de832487e":"Engineers test things on a computer before they build them","oss-fmi-profile-ladder.5ab6fc20bf":"Arithmetic base, Numerus","oss-fmi-profile-ladder.eadab572f6":"One model, one declared profile. Choose the numeric contract, then validate the result.","oss-fmi-profile-ladder.91ba7be7c7":"Fraction bits","oss-fmi-profile-ladder.9b5c593c34":"Integer bits","oss-fmi-profile-ladder.6d7ae87f78":"Best for","oss-fmi-profile-ladder.fbf68005eb":"Reference variance","oss-fmi-profile-ladder.7ac03632f2":"Verified against MPFR","oss-fmi-profile-ladder.39c9a45c59":"Verification harness","oss-fmi-profile-ladder.daa896bd82":"arbitrary precision","oss-fmi-profile-ladder.c4bd026c64":"Arbitrary-precision reference. Used for verification only. Every fixed-point operation is checked against it, and the conformance suite records any difference from the reference.","oss-fmi-profile-ladder.9b2d3887e5":"MPFR","oss-fmi-profile-ladder.b88853f152":"Billing and finance models","oss-fmi-profile-ladder.1809a96faa":"6 decimal digits","oss-fmi-profile-ladder.a9f7e0bb94":"64-bit decimal with 6 fractional digits. Banking, billing, and decimal-aware accounting. Avoids the binary to decimal rounding problem entirely.","oss-fmi-profile-ladder.7fdd34297b":"Dec64_6","oss-fmi-profile-ladder.4fad8dcaa3":"Workstation, CI, cluster","oss-fmi-profile-ladder.9d9123a420":"32 integer bits, 32 fraction bits. The default profile for general FMI simulation. Wide enough for most engineering models, friendly to a CPU.","oss-fmi-profile-ladder.ebbbaac6e5":"Cortex-M, RISC-V","oss-fmi-profile-ladder.03df7be3ee":"16 integer bits, 16 fraction bits. Memory and energy dominate over precision. Suited to control loops and sensor fusion on small targets.","oss-fmi-programme-continuity.chrome.path":"Programme continuity","oss-fmi-programme-continuity.chrome.status":"one model, five programme stages","oss-fmi-programme-continuity.chrome.meta":"handover count reduced","oss-fmi-programme-continuity.conventional.label":"conventional programme","oss-fmi-programme-continuity.conventional.note":"five models of the same machine","oss-fmi-programme-continuity.conventional.object-tag":"separate model","oss-fmi-programme-continuity.continuous.label":"with Dweve FMI","oss-fmi-programme-continuity.continuous.note":"one model through five execution contexts","oss-fmi-programme-continuity.continuous.model":"one FMI 3 model","oss-fmi-programme-continuity.continuous.provenance":"state and provenance continue underneath","oss-fmi-programme-continuity.stages.engineering-analysis.name":"engineering analysis","oss-fmi-programme-continuity.stages.engineering-analysis.conventional":"analysis model","oss-fmi-programme-continuity.stages.system-integration.name":"system integration","oss-fmi-programme-continuity.stages.system-integration.conventional":"co-simulation build","oss-fmi-programme-continuity.stages.high-performance-study.name":"high-performance study","oss-fmi-programme-continuity.stages.high-performance-study.conventional":"accelerated version","oss-fmi-programme-continuity.stages.embedded-deployment.name":"embedded deployment","oss-fmi-programme-continuity.stages.embedded-deployment.conventional":"controller reimplementation","oss-fmi-programme-continuity.stages.operations.name":"operations","oss-fmi-programme-continuity.stages.operations.conventional":"Twin integration","oss-fmi-programme-continuity.drift.label":"differences accumulate","oss-fmi-programme-continuity.drift.variable-names":"variable names","oss-fmi-programme-continuity.drift.units":"units","oss-fmi-programme-continuity.drift.solver-assumptions":"solver assumptions","oss-fmi-programme-continuity.removed.label":"no longer on the route","oss-fmi-programme-continuity.removed.accelerated-rewrite":"accelerated rewrite project","oss-fmi-programme-continuity.removed.embedded-reimplementation":"embedded reimplementation","oss-fmi-programme-continuity.removed.twin-remodel":"post-handover Twin remodel","oss-fmi-programme-continuity.kept.target-work":"target-specific deployment work remains","oss-fmi-programme-continuity.band.text":"one model carries the programme","oss-fmi-programme-continuity.band.meta":"five stages, one contract","oss-fmi-provenance-fields.kicker.label":"A value’s route","oss-fmi-provenance-fields.kicker.sub":"from origin to surviving state","oss-fmi-provenance-fields.tag":"LINEAGE","oss-fmi-provenance-fields.stage.origin.name":"Origin","oss-fmi-provenance-fields.stage.origin.context":"FMU, Twin, sensor or external input","oss-fmi-provenance-fields.stage.origin.question":"who produced it","oss-fmi-provenance-fields.stage.origin.use":"supplier and subsystem trace","oss-fmi-provenance-fields.stage.mapping.name":"Mapping","oss-fmi-provenance-fields.stage.mapping.context":"source, target, direction and units","oss-fmi-provenance-fields.stage.mapping.question":"how it crossed","oss-fmi-provenance-fields.stage.mapping.use":"integration review","oss-fmi-provenance-fields.stage.transformation.name":"Transformation","oss-fmi-provenance-fields.stage.transformation.context":"factor, offset and custom rule","oss-fmi-provenance-fields.stage.transformation.question":"how the value changed","oss-fmi-provenance-fields.stage.transformation.use":"reproduction","oss-fmi-provenance-fields.stage.validation.name":"Validation","oss-fmi-provenance-fields.stage.validation.context":"rules passed or failed","oss-fmi-provenance-fields.stage.validation.question":"why it was accepted","oss-fmi-provenance-fields.stage.validation.use":"quality and incident review","oss-fmi-provenance-fields.stage.time.name":"Time","oss-fmi-provenance-fields.stage.time.context":"simulation, processing and validity","oss-fmi-provenance-fields.stage.time.question":"what was known when","oss-fmi-provenance-fields.stage.time.use":"temporal reconstruction","oss-fmi-provenance-fields.stage.resolution.name":"Resolution","oss-fmi-provenance-fields.stage.resolution.context":"policy and decision","oss-fmi-provenance-fields.stage.resolution.question":"why this value survived","oss-fmi-provenance-fields.stage.resolution.use":"accountability","oss-fmi-provenance-fields.labels.laterUse":"later use","oss-fmi-provenance-fields.foot.left":"the value is useful now","oss-fmi-provenance-fields.foot.right":"its route is useful later","oss-fmi-reopen-past.chrome.path":"Reopen a saved test","oss-fmi-reopen-past.chrome.status":"one past, three futures","oss-fmi-reopen-past.chrome.meta":"same starting state, illustrative","oss-fmi-reopen-past.rewind.mark":"first pressure conflict","oss-fmi-reopen-past.rewind.note":"simulation and Twin history rewound to one shared point","oss-fmi-reopen-past.route.original.name":"the original route","oss-fmi-reopen-past.route.original.note":"continues through the manual selection","oss-fmi-reopen-past.route.model-value.name":"branch: model value","oss-fmi-reopen-past.route.model-value.note":"selects the model's value instead","oss-fmi-reopen-past.route.mapping-offset.name":"branch: mapping offset","oss-fmi-reopen-past.route.mapping-offset.note":"changes the offset before replay","oss-fmi-reopen-past.route.record":"decision record kept","oss-fmi-reopen-past.compare.label":"the three outcomes, key by key","oss-fmi-reopen-past.compare.pressure.label":"pressure","oss-fmi-reopen-past.compare.pressure.original":"4.32 bar used","oss-fmi-reopen-past.compare.pressure.model-value":"4.10 bar used","oss-fmi-reopen-past.compare.pressure.mapping-offset":"shifted before replay","oss-fmi-reopen-past.compare.controller-response.label":"controller response","oss-fmi-reopen-past.compare.controller-response.original":"as recorded","oss-fmi-reopen-past.compare.controller-response.model-value":"differs from the original","oss-fmi-reopen-past.compare.controller-response.mapping-offset":"differs from the original","oss-fmi-reopen-past.compare.predicted-wear.label":"predicted wear","oss-fmi-reopen-past.compare.predicted-wear.original":"as recorded","oss-fmi-reopen-past.compare.predicted-wear.model-value":"differs from the original","oss-fmi-reopen-past.compare.predicted-wear.mapping-offset":"differs from the original","oss-fmi-reopen-past.compare.alarm-state.label":"alarm state","oss-fmi-reopen-past.compare.alarm-state.original":"as recorded","oss-fmi-reopen-past.compare.alarm-state.model-value":"differs from the original","oss-fmi-reopen-past.compare.alarm-state.mapping-offset":"differs from the original","oss-fmi-reopen-past.band.left":"the past is a state, not a picture","oss-fmi-reopen-past.band.right":"three futures, one start","oss-fmi-same-answer.0ff2fd246a":"Think of it like a good ruler. It measures the same whether you use it at home or at the\n          workshop.","oss-fmi-same-answer.d930000713":"On ordinary computers the two answers can differ a tiny bit. Usually that is fine. For a\n            brake or a heart pump, even a tiny difference is a reason to worry.","oss-fmi-same-answer.2880aed446":"Not quite the same.","oss-fmi-same-answer.2b6e200d2c":"Both computers are compared, so the safety team can trust the record and see whether a\n            different machine produced something else.","oss-fmi-same-answer.a0d01316ad":"The declared comparison.","oss-fmi-same-answer.8a46ff4c83":"safety check reading","oss-fmi-same-answer.e6c58b3af9":"Test result","oss-fmi-same-answer.5833d71461":"Computer in the safety office","oss-fmi-same-answer.b55a654d2e":"A little different","oss-fmi-same-answer.b883e458a4":"Compared under contract","oss-fmi-same-answer.b8c126f54b":"Computer at the desk","oss-fmi-same-answer.e0d1dc9c8a":"With this","oss-fmi-same-answer.829b0d47de":"The old way","oss-fmi-same-answer.b4aea54e4e":"Choose a way","oss-fmi-same-answer.fa831a9770":"Flip the switch and watch what changes.","oss-fmi-same-answer.b11ca4d4ba":"Two computers, one test","oss-fmi-same-model-many-places.chrome.path":"One model, many places","oss-fmi-same-model-many-places.chrome.status":"five execution settings, one model","oss-fmi-same-model-many-places.chrome.meta":"results comparable","oss-fmi-same-model-many-places.rail.model":"one model, never copied","oss-fmi-same-model-many-places.setting.desk.name":"Desk","oss-fmi-same-model-many-places.setting.desk.measure":"immediate response","oss-fmi-same-model-many-places.setting.gpu-server.name":"GPU server","oss-fmi-same-model-many-places.setting.gpu-server.measure":"many parallel cases","oss-fmi-same-model-many-places.setting.dedicated-chip.name":"Dedicated-chip rack","oss-fmi-same-model-many-places.setting.dedicated-chip.measure":"fixed latency","oss-fmi-same-model-many-places.setting.embedded-controller.name":"Embedded controller","oss-fmi-same-model-many-places.setting.embedded-controller.measure":"memory budget","oss-fmi-same-model-many-places.setting.cluster.name":"Cluster","oss-fmi-same-model-many-places.setting.cluster.measure":"distributed capacity","oss-fmi-same-model-many-places.shared.variables.label":"same variables","oss-fmi-same-model-many-places.shared.variables.text":"the same named list under all five","oss-fmi-same-model-many-places.shared.history.label":"one state history","oss-fmi-same-model-many-places.shared.history.text":"one shared shape, so results compare","oss-fmi-same-model-many-places.alternative.label":"the conventional way","oss-fmi-same-model-many-places.alternative.card":"implementation","oss-fmi-same-model-many-places.alternative.note":"five separately maintained versions of the same machine","oss-fmi-same-model-many-places.band.left":"the computer changes, the question does not","oss-fmi-same-model-many-places.band.right":"one model, carried everywhere","oss-fmi-saved-moment.kicker.label":"What is saved","oss-fmi-saved-moment.kicker.sub":"so the moment is complete","oss-fmi-saved-moment.tag":"PLAIN","oss-fmi-saved-moment.saved.values.name":"Values","oss-fmi-saved-moment.saved.values.description":"where every quantity stood","oss-fmi-saved-moment.saved.values.why":"restart the model","oss-fmi-saved-moment.saved.time-and-mode.name":"Time and mode","oss-fmi-saved-moment.saved.time-and-mode.description":"where the run had reached","oss-fmi-saved-moment.saved.time-and-mode.why":"continue legally","oss-fmi-saved-moment.saved.clocks-and-events.name":"Clocks and events","oss-fmi-saved-moment.saved.clocks-and-events.description":"what was waiting to happen","oss-fmi-saved-moment.saved.clocks-and-events.why":"preserve order","oss-fmi-saved-moment.saved.solver-state.name":"Solver state","oss-fmi-saved-moment.saved.solver-state.description":"how the next step was being chosen","oss-fmi-saved-moment.saved.solver-state.why":"continue the same route","oss-fmi-saved-moment.saved.run-identity.name":"Run identity","oss-fmi-saved-moment.saved.run-identity.description":"which model and settings this belongs to","oss-fmi-saved-moment.saved.run-identity.why":"open the right save","oss-fmi-saved-moment.foot.left":"save the whole moment","oss-fmi-saved-moment.foot.right":"not only the visible result","oss-fmi-scale-ladder.chrome.path":"Scale on your terms","oss-fmi-scale-ladder.chrome.status":"four scales, one model spine","oss-fmi-scale-ladder.chrome.meta":"acceptance evidence per move","oss-fmi-scale-ladder.spine.model":"Battery-thermal model","oss-fmi-scale-ladder.spine.identity":"state and variable identity","oss-fmi-scale-ladder.spine.climb":"one model climbs","oss-fmi-scale-ladder.stage.interactive.name":"Local CPU","oss-fmi-scale-ladder.stage.interactive.posture":"interactive engineering","oss-fmi-scale-ladder.stage.interactive.evidence.reference":"reference trajectory","oss-fmi-scale-ladder.stage.interactive.evidence.parity":"trajectory parity","oss-fmi-scale-ladder.stage.interactive.summary":"The model runs interactively on a local CPU during design. The reference trajectory recorded here is the baseline every later stage is accepted against.","oss-fmi-scale-ladder.stage.sweep.name":"GPU sweep","oss-fmi-scale-ladder.stage.sweep.posture":"parameter sweep","oss-fmi-scale-ladder.stage.sweep.evidence.variants":"variant hashes","oss-fmi-scale-ladder.stage.sweep.evidence.batch":"batch identity","oss-fmi-scale-ladder.stage.sweep.evidence.divergence":"first divergence","oss-fmi-scale-ladder.stage.sweep.summary":"The same model moves to a GPU ensemble for the parameter sweep. Variant and batch hashes keep every result attributable, and the first divergence from the reference trajectory is part of the acceptance evidence.","oss-fmi-scale-ladder.stage.hil.name":"FPGA HIL","oss-fmi-scale-ladder.stage.hil.posture":"hardware-in-the-loop","oss-fmi-scale-ladder.stage.hil.evidence.latency":"latency","oss-fmi-scale-ladder.stage.hil.evidence.memory":"memory","oss-fmi-scale-ladder.stage.hil.evidence.parity":"state parity","oss-fmi-scale-ladder.stage.hil.summary":"Hardware-in-the-loop runs the model on FPGA or a real-time CPU. Latency, memory and state parity against the reference decide whether the move is accepted.","oss-fmi-scale-ladder.stage.distributed.name":"Distributed pack simulation","oss-fmi-scale-ladder.stage.distributed.posture":"system or fleet study","oss-fmi-scale-ladder.stage.distributed.evidence.checkpoint":"global checkpoint","oss-fmi-scale-ladder.stage.distributed.evidence.boundary":"boundary trace","oss-fmi-scale-ladder.stage.distributed.summary":"Distributed placement scales the model into a pack-level study across nodes. A global checkpoint and the boundary trace carry the run’s identity across the placement.","oss-fmi-scale-ladder.readout.evidenceLabel":"acceptance evidence","oss-fmi-scale-ladder.band.left":"state and variable identity stay on the spine","oss-fmi-scale-ladder.band.right":"capacity follows the programme","oss-fmi-scale-stages.kicker.label":"Four scale stages","oss-fmi-scale-stages.kicker.sub":"one model throughout","oss-fmi-scale-stages.tag":"SCALE","oss-fmi-scale-stages.stage.one.workload":"interactive engineering","oss-fmi-scale-stages.stage.one.posture":"local CPU","oss-fmi-scale-stages.stage.one.evidence":"reference trajectory","oss-fmi-scale-stages.stage.two.workload":"parameter sweep","oss-fmi-scale-stages.stage.two.posture":"GPU ensemble","oss-fmi-scale-stages.stage.two.evidence":"variant and batch hashes","oss-fmi-scale-stages.stage.three.workload":"hardware-in-the-loop","oss-fmi-scale-stages.stage.three.posture":"FPGA or real-time CPU","oss-fmi-scale-stages.stage.three.evidence":"latency and state parity","oss-fmi-scale-stages.stage.four.workload":"system or fleet study","oss-fmi-scale-stages.stage.four.posture":"distributed placement","oss-fmi-scale-stages.stage.four.evidence":"global checkpoint and boundary trace","oss-fmi-scale-stages.labels.evidence":"evidence","oss-fmi-scale-stages.foot.left":"capacity changes by phase","oss-fmi-scale-stages.foot.right":"the model contract stays stable","oss-fmi-solver-dispatch.chrome.path":"Solver selection","oss-fmi-solver-dispatch.chrome.status":"five problems, one result contract","oss-fmi-solver-dispatch.chrome.meta":"registry generated","oss-fmi-solver-dispatch.classifier.title":"classifier: problem description","oss-fmi-solver-dispatch.facts.stiffness":"stiffness estimate","oss-fmi-solver-dispatch.facts.mass-matrix":"mass matrix","oss-fmi-solver-dispatch.facts.stochastic":"stochastic terms","oss-fmi-solver-dispatch.facts.events":"event functions","oss-fmi-solver-dispatch.facts.coupling":"coupling SCC","oss-fmi-solver-dispatch.models.oscillator.name":"Smooth oscillator","oss-fmi-solver-dispatch.models.oscillator.tag":"non-stiff ODE","oss-fmi-solver-dispatch.models.oscillator.facts.stiffness":"low","oss-fmi-solver-dispatch.models.oscillator.facts.mass-matrix":"none","oss-fmi-solver-dispatch.models.oscillator.facts.stochastic":"none","oss-fmi-solver-dispatch.models.oscillator.facts.events":"zero-crossing indicators","oss-fmi-solver-dispatch.models.oscillator.facts.coupling":"none","oss-fmi-solver-dispatch.models.oscillator.route.name":"Embedded adaptive Runge-Kutta","oss-fmi-solver-dispatch.models.oscillator.route.steps.0":"derivative stages","oss-fmi-solver-dispatch.models.oscillator.route.steps.1":"local error estimate","oss-fmi-solver-dispatch.models.oscillator.route.steps.2":"accepted step","oss-fmi-solver-dispatch.models.oscillator.readout":"Smooth dynamics with indicators to watch: the classifier sees low stiffness and no mass matrix, so an embedded adaptive Runge-Kutta route controls error through deterministic adaptive stepping and reports every accepted step.","oss-fmi-solver-dispatch.models.thermal.name":"Stiff thermal network","oss-fmi-solver-dispatch.models.thermal.tag":"stiff ODE","oss-fmi-solver-dispatch.models.thermal.facts.stiffness":"high","oss-fmi-solver-dispatch.models.thermal.facts.mass-matrix":"none","oss-fmi-solver-dispatch.models.thermal.facts.stochastic":"none","oss-fmi-solver-dispatch.models.thermal.facts.events":"none","oss-fmi-solver-dispatch.models.thermal.facts.coupling":"none","oss-fmi-solver-dispatch.models.thermal.route.name":"Implicit BDF","oss-fmi-solver-dispatch.models.thermal.route.steps.0":"explicit route rejected","oss-fmi-solver-dispatch.models.thermal.route.steps.1":"nonlinear Newton iteration","oss-fmi-solver-dispatch.models.thermal.route.steps.2":"residual within tolerance","oss-fmi-solver-dispatch.models.thermal.rejection":"Explicit route rejected before execution: the stiffness estimate exceeds the explicit stability bound, so the run moves to an implicit route.","oss-fmi-solver-dispatch.models.thermal.readout":"The stiffness estimate rules the explicit route out before a step is taken. The classifier moves the model to an implicit BDF route, and the transition appears in the run record rather than hiding behind do step.","oss-fmi-solver-dispatch.models.mass-matrix-dae.name":"Mass-matrix DAE","oss-fmi-solver-dispatch.models.mass-matrix-dae.tag":"differential-algebraic","oss-fmi-solver-dispatch.models.mass-matrix-dae.facts.stiffness":"moderate","oss-fmi-solver-dispatch.models.mass-matrix-dae.facts.mass-matrix":"present","oss-fmi-solver-dispatch.models.mass-matrix-dae.facts.stochastic":"none","oss-fmi-solver-dispatch.models.mass-matrix-dae.facts.events":"none","oss-fmi-solver-dispatch.models.mass-matrix-dae.facts.coupling":"none","oss-fmi-solver-dispatch.models.mass-matrix-dae.route.name":"Mass-matrix DAE route","oss-fmi-solver-dispatch.models.mass-matrix-dae.route.steps.0":"mass-matrix solve","oss-fmi-solver-dispatch.models.mass-matrix-dae.route.steps.1":"index reduction","oss-fmi-solver-dispatch.models.mass-matrix-dae.route.steps.2":"consistent state returned","oss-fmi-solver-dispatch.models.mass-matrix-dae.readout":"A declared mass matrix keeps this model off the ordinary explicit paths. The DAE route solves with the matrix, applies index reduction and returns a consistent state through the same result shape.","oss-fmi-solver-dispatch.models.sensor.name":"Stochastic sensor model","oss-fmi-solver-dispatch.models.sensor.tag":"SDE","oss-fmi-solver-dispatch.models.sensor.facts.stiffness":"low","oss-fmi-solver-dispatch.models.sensor.facts.mass-matrix":"none","oss-fmi-solver-dispatch.models.sensor.facts.stochastic":"present under declared noise","oss-fmi-solver-dispatch.models.sensor.facts.events":"threshold indicators","oss-fmi-solver-dispatch.models.sensor.facts.coupling":"none","oss-fmi-solver-dispatch.models.sensor.route.name":"Euler-Maruyama","oss-fmi-solver-dispatch.models.sensor.route.steps.0":"deterministic noise draw","oss-fmi-solver-dispatch.models.sensor.route.steps.1":"drift and diffusion step","oss-fmi-solver-dispatch.models.sensor.route.steps.2":"noise state retained","oss-fmi-solver-dispatch.models.sensor.readout":"Declared stochastic terms route the model to Euler-Maruyama under an explicit deterministic noise contract, so the noise state is retained and the run stays replayable.","oss-fmi-solver-dispatch.models.algebraic-loop.name":"Two-FMU algebraic loop","oss-fmi-solver-dispatch.models.algebraic-loop.tag":"strongly connected","oss-fmi-solver-dispatch.models.algebraic-loop.facts.stiffness":"not applicable","oss-fmi-solver-dispatch.models.algebraic-loop.facts.mass-matrix":"none","oss-fmi-solver-dispatch.models.algebraic-loop.facts.stochastic":"none","oss-fmi-solver-dispatch.models.algebraic-loop.facts.events":"none","oss-fmi-solver-dispatch.models.algebraic-loop.facts.coupling":"one strongly connected group","oss-fmi-solver-dispatch.models.algebraic-loop.route.name":"Coupled-loop damped Newton","oss-fmi-solver-dispatch.models.algebraic-loop.route.steps.0":"group residual formed","oss-fmi-solver-dispatch.models.algebraic-loop.route.steps.1":"damped Newton iteration","oss-fmi-solver-dispatch.models.algebraic-loop.route.steps.2":"converged fixed point","oss-fmi-solver-dispatch.models.algebraic-loop.readout":"The coupling SCC marks the two FMUs as one algebraic group. A damped Newton route iterates the group residual to convergence and returns the group, the iterations and the residual history.","oss-fmi-solver-dispatch.result.label":"identical result object","oss-fmi-solver-dispatch.result.fields.0":"state","oss-fmi-solver-dispatch.result.fields.1":"time","oss-fmi-solver-dispatch.result.fields.2":"evaluations","oss-fmi-solver-dispatch.result.fields.3":"iterations","oss-fmi-solver-dispatch.result.fields.4":"residual","oss-fmi-solver-dispatch.result.fields.5":"error estimate","oss-fmi-solver-dispatch.result.fields.6":"event","oss-fmi-solver-dispatch.result.fields.7":"status","oss-fmi-solver-dispatch.band.text":"Selection is part of the run record.","oss-fmi-solver-dispatch.band.meta":"one result contract","oss-fmi-solver-families.kicker.label":"The registry","oss-fmi-solver-families.kicker.sub":"families rather than one enum","oss-fmi-solver-families.tag":"DISPATCH","oss-fmi-solver-families.columns.selected-for":"selected for","oss-fmi-solver-families.columns.evidence":"evidence returned","oss-fmi-solver-families.families.explicit-ode.name":"Explicit ODE","oss-fmi-solver-families.families.explicit-ode.routes.0":"Euler","oss-fmi-solver-families.families.explicit-ode.routes.1":"midpoint","oss-fmi-solver-families.families.explicit-ode.routes.2":"RK","oss-fmi-solver-families.families.explicit-ode.routes.3":"embedded RK","oss-fmi-solver-families.families.explicit-ode.selected-for":"non-stiff and fixed-step systems","oss-fmi-solver-families.families.explicit-ode.evidence":"stages, local error, accepted step","oss-fmi-solver-families.families.implicit-dae.name":"Implicit and DAE","oss-fmi-solver-families.families.implicit-dae.routes.0":"backward","oss-fmi-solver-families.families.implicit-dae.routes.1":"trapezoidal","oss-fmi-solver-families.families.implicit-dae.routes.2":"BDF","oss-fmi-solver-families.families.implicit-dae.routes.3":"DASSL-style","oss-fmi-solver-families.families.implicit-dae.selected-for":"stiff and mass-matrix systems","oss-fmi-solver-families.families.implicit-dae.evidence":"nonlinear iterations and residual","oss-fmi-solver-families.families.stochastic.name":"Stochastic","oss-fmi-solver-families.families.stochastic.routes.0":"Euler-Maruyama","oss-fmi-solver-families.families.stochastic.routes.1":"Milstein-style","oss-fmi-solver-families.families.stochastic.selected-for":"SDE models under declared noise","oss-fmi-solver-families.families.stochastic.evidence":"noise state and step trace","oss-fmi-solver-families.families.root-interval.name":"Root and interval","oss-fmi-solver-families.families.root-interval.routes.0":"bisection","oss-fmi-solver-families.families.root-interval.routes.1":"Brent","oss-fmi-solver-families.families.root-interval.routes.2":"Newton","oss-fmi-solver-families.families.root-interval.routes.3":"interval Newton","oss-fmi-solver-families.families.root-interval.selected-for":"events, equilibria and implicit equations","oss-fmi-solver-families.families.root-interval.evidence":"bracket, residual and convergence","oss-fmi-solver-families.families.coupled-loops.name":"Coupled loops","oss-fmi-solver-families.families.coupled-loops.routes.0":"fixed-point","oss-fmi-solver-families.families.coupled-loops.routes.1":"damped Newton","oss-fmi-solver-families.families.coupled-loops.selected-for":"strongly connected FMU groups","oss-fmi-solver-families.families.coupled-loops.evidence":"group, iterations and residual history","oss-fmi-solver-families.footline.left":"the method changes","oss-fmi-solver-families.footline.right":"the result contract does not","oss-fmi-sovereignty-panel.76b4d9f30d":"On premise, EU region, your hardware","oss-fmi-sovereignty-panel.eedfb20e57":"Sovereignty is the default, not an upgrade.","oss-fmi-sovereignty-panel.4380c52ca5":"The same verified model runs in three deployment postures, and the choice remains yours.","oss-fmi-sovereignty-panel.0b26841d97":"You decide where it runs","oss-fmi-sovereignty-panel.870c4d024a":"Model and evidence remain yours","oss-fmi-sovereignty-panel.b89ab9ee88":"No hosted service is required","oss-fmi-sovereignty-panel.3915907107":"Compared across supported targets","oss-fmi-sovereignty-panel.df4ca35cc7":"It does not need a special or expensive machine. The same work runs on a desktop, a cluster, or specialist hardware.","oss-fmi-sovereignty-panel.922a5ba56b":"On the kit you have","oss-fmi-sovereignty-panel.5ef2228054":"Run it in a European location. Your simulation work stays inside a border you choose.","oss-fmi-sovereignty-panel.b1b2be57a5":"In a European region","oss-fmi-sovereignty-panel.e7885accd0":"Run it inside your own building, on the computers you already own. Nothing has to leave the site.","oss-fmi-sovereignty-panel.8c0f01c721":"On your own machines","oss-fmi-sovereignty-panel.11421f13a8":"ON PREMISE","oss-fmi-sovereignty-panel.503d28b412":"EU REGION","oss-fmi-sovereignty-panel.1d947a2c47":"YOUR HARDWARE","oss-fmi-state-contents.kicker.label":"A saved simulation","oss-fmi-state-contents.kicker.sub":"more than a vector","oss-fmi-state-contents.tag":"PERSISTENT","oss-fmi-state-contents.part.values.name":"Continuous and discrete values","oss-fmi-state-contents.part.values.why":"recreate model state","oss-fmi-state-contents.part.values.checked":"type, count and range","oss-fmi-state-contents.part.values.used-by":"resume and branch","oss-fmi-state-contents.part.time-mode.name":"Time and mode","oss-fmi-state-contents.part.time-mode.why":"return to the same lifecycle point","oss-fmi-state-contents.part.time-mode.checked":"valid transition state","oss-fmi-state-contents.part.time-mode.used-by":"continued execution","oss-fmi-state-contents.part.clocks.name":"Clocks and indicators","oss-fmi-state-contents.part.clocks.why":"preserve pending events","oss-fmi-state-contents.part.clocks.checked":"identity and activation state","oss-fmi-state-contents.part.clocks.used-by":"scheduled execution","oss-fmi-state-contents.part.solver.name":"Solver and loop state","oss-fmi-state-contents.part.solver.why":"continue adaptive or implicit work","oss-fmi-state-contents.part.solver.checked":"method and format version","oss-fmi-state-contents.part.solver.used-by":"exact continuation","oss-fmi-state-contents.part.identity.name":"Run identity","oss-fmi-state-contents.part.identity.why":"bind state to model and configuration","oss-fmi-state-contents.part.identity.checked":"compatibility","oss-fmi-state-contents.part.identity.used-by":"replay and comparison","oss-fmi-state-contents.footline.left":"restore the run","oss-fmi-state-contents.footline.right":"not merely the last outputs","oss-fmi-study-economics.kicker.label":"What a checkpoint changes","oss-fmi-study-economics.kicker.sub":"for a long-running study","oss-fmi-study-economics.tag":"CONTINUITY","oss-fmi-study-economics.rows.host-restart.concern":"Host restart","oss-fmi-study-economics.rows.host-restart.without":"begin again","oss-fmi-study-economics.rows.host-restart.with":"resume from compatible checkpoint","oss-fmi-study-economics.rows.host-restart.decision":"checkpoint cadence","oss-fmi-study-economics.rows.worker-replacement.concern":"Worker replacement","oss-fmi-study-economics.rows.worker-replacement.without":"machine-bound run","oss-fmi-study-economics.rows.worker-replacement.with":"move state to another worker","oss-fmi-study-economics.rows.worker-replacement.decision":"backend compatibility","oss-fmi-study-economics.rows.parameter-alternative.concern":"Parameter alternative","oss-fmi-study-economics.rows.parameter-alternative.without":"rerun shared history","oss-fmi-study-economics.rows.parameter-alternative.with":"branch from chosen state","oss-fmi-study-economics.rows.parameter-alternative.decision":"changed parameter set","oss-fmi-study-economics.rows.post-event-analysis.concern":"Post-event analysis","oss-fmi-study-economics.rows.post-event-analysis.without":"inspect final outputs","oss-fmi-study-economics.rows.post-event-analysis.with":"replay to first divergence","oss-fmi-study-economics.rows.post-event-analysis.decision":"history and provenance","oss-fmi-study-economics.foot.left":"the process is temporary","oss-fmi-study-economics.foot.right":"the study state is not","oss-fmi-supplier-bench.chrome.path":"Suppliers","oss-fmi-supplier-bench.chrome.status":"one accepted, two returned with findings","oss-fmi-supplier-bench.chrome.meta":"supplier models remain separate","oss-fmi-supplier-bench.bench.label":"shared intake bench","oss-fmi-supplier-bench.report.interfaces":"interface types","oss-fmi-supplier-bench.report.findings":"findings","oss-fmi-supplier-bench.report.recommendation":"recommendation","oss-fmi-supplier-bench.report.warnings":"warnings","oss-fmi-supplier-bench.report.tag":"portable report, returnable to the supplier","oss-fmi-supplier-bench.packages.controller.model":"controller FMU","oss-fmi-supplier-bench.packages.controller.supplier":"supplier A, model ID on file","oss-fmi-supplier-bench.packages.controller.interfaces":"Model Exchange, Co-Simulation","oss-fmi-supplier-bench.packages.controller.verdict":"accepted","oss-fmi-supplier-bench.packages.controller.findings":"archive and model-description checks pass","oss-fmi-supplier-bench.packages.controller.recommendation":"hold at the gate until a separate run decision","oss-fmi-supplier-bench.packages.controller.warnings":"none recorded","oss-fmi-supplier-bench.packages.valve.model":"valve FMU","oss-fmi-supplier-bench.packages.valve.supplier":"supplier B, model ID on file","oss-fmi-supplier-bench.packages.valve.interfaces":"Co-Simulation","oss-fmi-supplier-bench.packages.valve.verdict":"refused before writing","oss-fmi-supplier-bench.packages.valve.findings":"an archive entry attempts to escape the extraction directory","oss-fmi-supplier-bench.packages.valve.recommendation":"return the report to the supplier; native binary not trusted","oss-fmi-supplier-bench.packages.valve.warnings":"extraction stayed inside the intended destination","oss-fmi-supplier-bench.packages.battery.model":"battery FMU","oss-fmi-supplier-bench.packages.battery.supplier":"supplier C, model ID on file","oss-fmi-supplier-bench.packages.battery.interfaces":"Co-Simulation, Scheduled Execution","oss-fmi-supplier-bench.packages.battery.verdict":"returned with findings","oss-fmi-supplier-bench.packages.battery.findings":"valid archive; clock dependency inconsistent with declared capabilities","oss-fmi-supplier-bench.packages.battery.recommendation":"supplier corrects the capability declaration, then resubmits","oss-fmi-supplier-bench.packages.battery.warnings":"execution deferred until the declarations agree","oss-fmi-supplier-bench.gate.title":"Execution gate","oss-fmi-supplier-bench.gate.state":"closed","oss-fmi-supplier-bench.gate.note":"Execution is a deliberate next step, not a side effect of inspecting the package.","oss-fmi-supplier-bench.gate.waiting":"the accepted package waits here","oss-fmi-supplier-bench.band.text":"inspection precedes execution","oss-fmi-supplier-bench.band.meta":"one bench, three decisions","oss-fmi-supplier-intake.kicker.label":"An FMU on arrival","oss-fmi-supplier-intake.kicker.sub":"four separate decisions","oss-fmi-supplier-intake.tag":"INTAKE","oss-fmi-supplier-intake.columns.receives":"buyer receives","oss-fmi-supplier-intake.rows.inspect-archive.stage":"Inspect archive","oss-fmi-supplier-intake.rows.inspect-archive.does":"read entries and containment","oss-fmi-supplier-intake.rows.inspect-archive.receives":"archive findings","oss-fmi-supplier-intake.rows.inspect-archive.owner":"security or integration","oss-fmi-supplier-intake.rows.parse-description.stage":"Parse description","oss-fmi-supplier-intake.rows.parse-description.does":"validate FMI 3 identity and schema","oss-fmi-supplier-intake.rows.parse-description.receives":"required fields and capabilities","oss-fmi-supplier-intake.rows.parse-description.owner":"model owner","oss-fmi-supplier-intake.rows.validate-contract.stage":"Validate model contract","oss-fmi-supplier-intake.rows.validate-contract.does":"types, causality, clocks and dependencies","oss-fmi-supplier-intake.rows.validate-contract.receives":"standard-keyed findings","oss-fmi-supplier-intake.rows.validate-contract.owner":"systems engineer","oss-fmi-supplier-intake.rows.load-instantiate.stage":"Load and instantiate","oss-fmi-supplier-intake.rows.load-instantiate.does":"select compatible binary or Rust model path","oss-fmi-supplier-intake.rows.load-instantiate.receives":"runtime result","oss-fmi-supplier-intake.rows.load-instantiate.owner":"approved host process","oss-fmi-supplier-intake.foot.left":"read first","oss-fmi-supplier-intake.foot.right":"run only after the package is understood","oss-fmi-supplier-system.chrome.path":"Supplier system","oss-fmi-supplier-system.chrome.status":"ownership preserved, failure localised","oss-fmi-supplier-system.chrome.meta":"one system run","oss-fmi-supplier-system.graph.levels-note":"execution levels derived from the dependency graph","oss-fmi-supplier-system.graph.loop-group":"algebraic-loop group","oss-fmi-supplier-system.graph.feedback":"same-moment feedback inside the group","oss-fmi-supplier-system.fmus.controller.name":"controller","oss-fmi-supplier-system.fmus.controller.badge":"supplier A, v3","oss-fmi-supplier-system.fmus.inverter.name":"inverter","oss-fmi-supplier-system.fmus.inverter.badge":"supplier B, v2","oss-fmi-supplier-system.fmus.motor.name":"motor","oss-fmi-supplier-system.fmus.motor.badge":"supplier C, v4","oss-fmi-supplier-system.fmus.gearbox.name":"gearbox","oss-fmi-supplier-system.fmus.gearbox.badge":"supplier B, v1","oss-fmi-supplier-system.fmus.vehicle-body.name":"vehicle body","oss-fmi-supplier-system.fmus.vehicle-body.badge":"supplier D, v2","oss-fmi-supplier-system.links.torque-demand":"torque demand, Nm","oss-fmi-supplier-system.links.phase-current":"phase current, A","oss-fmi-supplier-system.links.shaft-torque":"shaft torque, Nm, scale 0.1","oss-fmi-supplier-system.links.wheel-force":"wheel force, N","oss-fmi-supplier-system.reports.loop.title":"loop report","oss-fmi-supplier-system.reports.loop.involved-key":"involved","oss-fmi-supplier-system.reports.loop.involved":"inverter, motor, gearbox","oss-fmi-supplier-system.reports.loop.residual-key":"residual","oss-fmi-supplier-system.reports.loop.residual":"above the declared tolerance at the iteration bound","oss-fmi-supplier-system.reports.loop.policy-key":"solver policy","oss-fmi-supplier-system.reports.loop.policy":"fixed point, declared tolerance","oss-fmi-supplier-system.reports.loop.note":"controller and vehicle body remain plain, outside the finding","oss-fmi-supplier-system.reports.connection.title":"connection report","oss-fmi-supplier-system.reports.connection.fault-key":"fault","oss-fmi-supplier-system.reports.connection.fault":"unit conversion on the shaft torque connection","oss-fmi-supplier-system.reports.connection.assigned-key":"assigned to","oss-fmi-supplier-system.reports.connection.assigned":"the systems integration layer","oss-fmi-supplier-system.reports.connection.clear-key":"not assigned to","oss-fmi-supplier-system.reports.connection.clear":"either model supplier","oss-fmi-supplier-system.reports.connection.note":"the finding routes to the owner of the transform","oss-fmi-supplier-system.band.text":"ownership preserved, failure localised","oss-fmi-supplier-system.band.meta":"one system run","oss-fmi-three-forms.kicker.label":"FMI 3 interface contracts","oss-fmi-three-forms.kicker.sub":"one or more host relationships","oss-fmi-three-forms.tag":"FMI 3","oss-fmi-three-forms.columns.host":"the host controls","oss-fmi-three-forms.columns.provides":"Dweve FMI provides","oss-fmi-three-forms.columns.operation":"central operation","oss-fmi-three-forms.forms.model-exchange.name":"Model Exchange","oss-fmi-three-forms.forms.model-exchange.host":"the integration loop","oss-fmi-three-forms.forms.model-exchange.provides":"states, derivatives, events and modes","oss-fmi-three-forms.forms.model-exchange.operation":"continuous-time progression","oss-fmi-three-forms.forms.co-simulation.name":"Co-Simulation","oss-fmi-three-forms.forms.co-simulation.host":"communication points","oss-fmi-three-forms.forms.co-simulation.provides":"internal stepping, early return and interpolation","oss-fmi-three-forms.forms.co-simulation.operation":"do step","oss-fmi-three-forms.forms.scheduled-execution.name":"Scheduled Execution","oss-fmi-three-forms.forms.scheduled-execution.host":"clock and partition activation","oss-fmi-three-forms.forms.scheduled-execution.provides":"clock state, dependencies and partition work","oss-fmi-three-forms.forms.scheduled-execution.operation":"activate model partition","oss-fmi-three-forms.forms.shared.name":"Shared underneath","oss-fmi-three-forms.forms.shared.host":"instance lifecycle","oss-fmi-three-forms.forms.shared.provides":"typed values, state, diagnostics and FMU state","oss-fmi-three-forms.forms.shared.operation":"one contract","oss-fmi-three-forms.footline.left":"three standard interface forms","oss-fmi-three-forms.footline.right":"the FMU declares its interface set","oss-fmi-three-parts.chrome.path":"Three parts, one system","oss-fmi-three-parts.chrome.status":"separate models, coordinated result","oss-fmi-three-parts.chrome.meta":"ownership preserved","oss-fmi-three-parts.run.ordered.label":"first run, order set","oss-fmi-three-parts.run.loop.label":"second run, same-moment feedback","oss-fmi-three-parts.box.controller":"controller","oss-fmi-three-parts.box.motor":"motor","oss-fmi-three-parts.box.load":"load","oss-fmi-three-parts.box.sealed":"sealed","oss-fmi-three-parts.value.command":"command","oss-fmi-three-parts.value.speed":"speed","oss-fmi-three-parts.value.power":"power","oss-fmi-three-parts.value.torque":"torque","oss-fmi-three-parts.loop.label":"loop group","oss-fmi-three-parts.loop.note":"iterated until the two values agree","oss-fmi-three-parts.failed.note":"if the values never agree, the run stops and names both parts and the remaining difference","oss-fmi-three-parts.band.left":"each box stays sealed","oss-fmi-three-parts.band.right":"the order is part of the test","oss-fmi-timeline-events.kicker.label":"One timeline","oss-fmi-timeline-events.kicker.sub":"several reasons to hand back control","oss-fmi-timeline-events.tag":"ORDERED","oss-fmi-timeline-events.columns.retained":"state retained","oss-fmi-timeline-events.columns.host-receives":"host receives","oss-fmi-timeline-events.causes.zero-crossing.cause":"Zero crossing","oss-fmi-timeline-events.causes.zero-crossing.action":"locate event and enter event handling","oss-fmi-timeline-events.causes.zero-crossing.host-receives":"event encountered and last time","oss-fmi-timeline-events.causes.zero-crossing.retained":"indicator and bracket","oss-fmi-timeline-events.causes.intermediate-update.cause":"Intermediate update","oss-fmi-timeline-events.causes.intermediate-update.action":"invoke callback during a step","oss-fmi-timeline-events.causes.intermediate-update.host-receives":"current values and progress","oss-fmi-timeline-events.causes.intermediate-update.retained":"resume point","oss-fmi-timeline-events.causes.clock-tick.cause":"Clock tick","oss-fmi-timeline-events.causes.clock-tick.action":"activate the clock and dependencies","oss-fmi-timeline-events.causes.clock-tick.host-receives":"tick and early-return context","oss-fmi-timeline-events.causes.clock-tick.retained":"next activation","oss-fmi-timeline-events.causes.model-partition.cause":"Model partition","oss-fmi-timeline-events.causes.model-partition.action":"run eligible partition","oss-fmi-timeline-events.causes.model-partition.host-receives":"partition status","oss-fmi-timeline-events.causes.model-partition.retained":"activation sequence","oss-fmi-timeline-events.causes.iteration-bound.cause":"Iteration bound","oss-fmi-timeline-events.causes.iteration-bound.action":"stop discrete settling","oss-fmi-timeline-events.causes.iteration-bound.host-receives":"round count and unresolved state","oss-fmi-timeline-events.causes.iteration-bound.retained":"terminal diagnostic","oss-fmi-timeline-events.footline.left":"events do not wait for the chart","oss-fmi-timeline-events.footline.right":"the host hears when they occur","oss-fmi-trust-promise.24e7e5249f":"You get the benefit. Someone else does the work.","oss-fmi-trust-promise.dce1df393c":"The simple answer","oss-fmi-trust-promise.b629985896":"You might wonder","oss-fmi-trust-promise.1855ea8e76":"Nothing here is for you to manage","oss-fmi-trust-promise.1ac18a63e8":"Yes. The declared contract makes each comparison visible.","oss-fmi-trust-promise.35ba245f5e":"Can I trust the result?","oss-fmi-trust-promise.9a4adbde8e":"It is designed and tested in Europe.","oss-fmi-trust-promise.7de6360d68":"Where does it come from?","oss-fmi-trust-promise.0f7dab6a35":"No. One validation record follows the model.","oss-fmi-trust-promise.aa1b0d7005":"Do engineers repeat every test?","oss-fmi-trust-promise.3aa684f049":"No. It works quietly in the background.","oss-fmi-trust-promise.431774a08e":"Do I have to understand it?","oss-fmi-twin-business-value.kicker.label":"What continues into operation","oss-fmi-twin-business-value.kicker.sub":"from the engineering model","oss-fmi-twin-business-value.tag":"OPERATIONAL","oss-fmi-twin-business-value.columns.record":"Twin record","oss-fmi-twin-business-value.rows.state-equations.asset":"State equations","oss-fmi-twin-business-value.rows.state-equations.use":"predict current and future behaviour","oss-fmi-twin-business-value.rows.state-equations.record":"model version and run","oss-fmi-twin-business-value.rows.state-equations.benefit":"less model reinvention","oss-fmi-twin-business-value.rows.parameters.asset":"Parameters","oss-fmi-twin-business-value.rows.parameters.use":"compare assumed and observed system","oss-fmi-twin-business-value.rows.parameters.record":"parameter provenance","oss-fmi-twin-business-value.rows.parameters.benefit":"calibration history","oss-fmi-twin-business-value.rows.failure-modes.asset":"Failure modes","oss-fmi-twin-business-value.rows.failure-modes.use":"run alternatives from live state","oss-fmi-twin-business-value.rows.failure-modes.record":"scenario branch","oss-fmi-twin-business-value.rows.failure-modes.benefit":"faster operational decisions","oss-fmi-twin-business-value.rows.variables-units.asset":"Variables and units","oss-fmi-twin-business-value.rows.variables-units.use":"map telemetry and predictions","oss-fmi-twin-business-value.rows.variables-units.record":"typed mapping","oss-fmi-twin-business-value.rows.variables-units.benefit":"fewer silent conversions","oss-fmi-twin-business-value.rows.simulation-state.asset":"Simulation state","oss-fmi-twin-business-value.rows.simulation-state.use":"resume and replay around incidents","oss-fmi-twin-business-value.rows.simulation-state.record":"event-sourced history","oss-fmi-twin-business-value.rows.simulation-state.benefit":"post-event evidence","oss-fmi-twin-business-value.foot.left":"the study ends","oss-fmi-twin-business-value.foot.right":"the model's useful life does not","oss-fmi-twin-crossing.chrome.path":"Model and asset","oss-fmi-twin-crossing.chrome.status":"four synchronised, one resolved","oss-fmi-twin-crossing.chrome.meta":"difference preserved, illustrative","oss-fmi-twin-crossing.endpoint.fmu.name":"pump FMU","oss-fmi-twin-crossing.endpoint.fmu.sub":"simulation side","oss-fmi-twin-crossing.endpoint.twin.name":"Dweve Twin","oss-fmi-twin-crossing.endpoint.twin.sub":"operational side","oss-fmi-twin-crossing.bridge.label":"the bridge, five mappings","oss-fmi-twin-crossing.mode.real-time":"real-time","oss-fmi-twin-crossing.mode.batch":"batch","oss-fmi-twin-crossing.state.crossed":"crossed","oss-fmi-twin-crossing.state.held":"held for manual","oss-fmi-twin-crossing.crossing.inlet-pressure.name":"inlet pressure","oss-fmi-twin-crossing.crossing.inlet-pressure.ref":"vr 12, measured","oss-fmi-twin-crossing.crossing.ambient-temperature.name":"ambient temperature","oss-fmi-twin-crossing.crossing.ambient-temperature.ref":"vr 17, measured","oss-fmi-twin-crossing.crossing.bearing-temperature.name":"predicted bearing temperature","oss-fmi-twin-crossing.crossing.bearing-temperature.ref":"vr 31, predicted","oss-fmi-twin-crossing.crossing.remaining-life.name":"remaining life","oss-fmi-twin-crossing.crossing.remaining-life.ref":"vr 34, predicted","oss-fmi-twin-crossing.crossing.discharge-pressure.name":"discharge pressure","oss-fmi-twin-crossing.crossing.discharge-pressure.ref":"vr 22, conflicted","oss-fmi-twin-crossing.conflict.head":"discharge pressure, both values kept","oss-fmi-twin-crossing.conflict.simulated.source":"simulated, FMU dischargePressure","oss-fmi-twin-crossing.conflict.simulated.value":"4.18 bar","oss-fmi-twin-crossing.conflict.simulated.meta":"t = 182.4 s, factor 1.0, offset 0","oss-fmi-twin-crossing.conflict.measured.source":"measured, Twin dischargePressure","oss-fmi-twin-crossing.conflict.measured.value":"4.31 bar","oss-fmi-twin-crossing.conflict.measured.meta":"validity 14:02:11, factor 1.0, offset 0","oss-fmi-twin-crossing.conflict.policy":"policy: manual","oss-fmi-twin-crossing.conflict.policy-note":"only this value is paused","oss-fmi-twin-crossing.resolution.decision":"a person selects the measured value","oss-fmi-twin-crossing.resolution.provenance":"the decision is kept as a provenance event","oss-fmi-twin-crossing.band.left":"four values cross while one waits","oss-fmi-twin-crossing.band.right":"difference preserved","oss-fmi-twin-mapping.kicker.label":"One mapped value","oss-fmi-twin-mapping.kicker.sub":"everything that travels with it","oss-fmi-twin-mapping.tag":"TWIN BRIDGE","oss-fmi-twin-mapping.field.source-target.name":"Source and target","oss-fmi-twin-mapping.field.source-target.example":"FMU pressure -> Twin dischargePressure","oss-fmi-twin-mapping.field.source-target.why":"lineage","oss-fmi-twin-mapping.field.source-target.query":"where did this value come from","oss-fmi-twin-mapping.field.direction.name":"Direction","oss-fmi-twin-mapping.field.direction.example":"bidirectional","oss-fmi-twin-mapping.field.direction.why":"authority context","oss-fmi-twin-mapping.field.direction.query":"which side changed it","oss-fmi-twin-mapping.field.transform.name":"Transform","oss-fmi-twin-mapping.field.transform.example":"factor, offset and unit","oss-fmi-twin-mapping.field.transform.why":"reproducibility","oss-fmi-twin-mapping.field.transform.query":"how was it mapped","oss-fmi-twin-mapping.field.times.name":"Three times","oss-fmi-twin-mapping.field.times.example":"simulation, processing, validity","oss-fmi-twin-mapping.field.times.why":"temporal truth","oss-fmi-twin-mapping.field.times.query":"what happened and what was known","oss-fmi-twin-mapping.field.validation.name":"Validation","oss-fmi-twin-mapping.field.validation.example":"range and custom rule","oss-fmi-twin-mapping.field.validation.why":"boundary evidence","oss-fmi-twin-mapping.field.validation.query":"why was it refused","oss-fmi-twin-mapping.field.conflict.name":"Conflict policy","oss-fmi-twin-mapping.field.conflict.example":"manual for safety pressure","oss-fmi-twin-mapping.field.conflict.why":"governance","oss-fmi-twin-mapping.field.conflict.query":"who selected the surviving value","oss-fmi-twin-mapping.footline.left":"a crossing is a recorded event","oss-fmi-twin-mapping.footline.right":"not a disappearing callback","oss-fmi-two-values.chrome.path":"Differences","oss-fmi-two-values.chrome.status":"one selected, two preserved","oss-fmi-two-values.chrome.meta":"difference becomes evidence, illustrative","oss-fmi-two-values.card.model.kind":"the model says","oss-fmi-two-values.card.model.note":"model and run named","oss-fmi-two-values.card.sensor.kind":"the machine says","oss-fmi-two-values.card.sensor.note":"sensor and time named","oss-fmi-two-values.versus":"versus","oss-fmi-two-values.policy.text":"the rule for this pressure: manual review, chosen before the disagreement","oss-fmi-two-values.decision.title":"a person decides","oss-fmi-two-values.decision.note":"the measured value is selected and a short reason is recorded","oss-fmi-two-values.next.label":"the next state","oss-fmi-two-values.next.retained":"4.10 bar stays on a visible branch with its simulation context","oss-fmi-two-values.grey.label":"an overwrite-only system","oss-fmi-two-values.grey.note":"would retain one unexplained number","oss-fmi-two-values.band.left":"both values stay in the history","oss-fmi-two-values.band.right":"the difference is evidence","oss-fmi-value-board.44d940e481":"One result contract everyone can review","oss-fmi-value-board.a5d808a7a1":"The same simulation is compared on every machine under a declared contract. Teams can see differences instead of reconciling numbers silently.","oss-fmi-value-board.91dae1340c":"A single set of results to stand behind","oss-fmi-value-board.c47309d293":"Time lost arguing whose machine is right","oss-fmi-value-board.a71897888d":"One declared safety record","oss-fmi-value-board.841cdb2b3d":"Because results are compared across platforms, you can scope the safety evidence to the declared targets. Moving to new hardware gets an explicit validation step.","oss-fmi-value-board.0022f98b68":"One validation effort, scoped to targets","oss-fmi-value-board.25916a456e":"Re-validating every time a chip changes","oss-fmi-value-board.870c4d024a":"No vendor lock-in","oss-fmi-value-board.96a6782a5f":"Dweve FMI addresses platform drift in simulation. Fixed-point profiles and backend checks make differences visible before they reach a safety case.","oss-fmi-value-board.01dcae259e":"Freedom to choose and to leave","oss-fmi-value-board.585c82b02f":"Being trapped with one vendor and one price","oss-fmi-value-board.9ab6c64424":"European, and on your own ground","oss-fmi-value-board.0936dc1875":"It runs on the hardware you already own, on premise or in an EU region. Your simulation data does not have to leave a border you control.","oss-fmi-value-board.a7d61623df":"Sovereignty over where work runs","oss-fmi-value-board.efd1aff28f":"Sending data to a platform you do not control","oss-fmi-value-board.0e0a8cef08":"You gain.","oss-fmi-value-board.5e926f9cde":"You avoid.","oss-fmi-value-board.f167ca4989":"The plain version.","oss-fmi-value-board.757b773ad8":"You spend less proving the same thing twice, and you keep control of\n          where your work runs.","oss-fmi-value-route.chrome.path":"Value history","oss-fmi-value-route.chrome.status":"one value, complete route","oss-fmi-value-route.chrome.meta":"reconstructable later, illustrative","oss-fmi-value-route.station.solver.name":"FMU solver","oss-fmi-value-route.station.solver.detail":"predicted bearing temperature","oss-fmi-value-route.station.reference.name":"Value reference","oss-fmi-value-route.station.reference.detail":"output bearing_temp","oss-fmi-value-route.station.conversion.name":"Unit conversion","oss-fmi-value-route.station.conversion.detail":"factor 1.0, °C","oss-fmi-value-route.station.validation.name":"Range validation","oss-fmi-value-route.station.validation.detail":"0 to 140 °C, passed","oss-fmi-value-route.station.sync.name":"Real-time sync","oss-fmi-value-route.station.sync.detail":"real-time posture","oss-fmi-value-route.station.event.name":"Twin event","oss-fmi-value-route.station.event.detail":"state event written","oss-fmi-value-route.value.label":"predicted bearing temperature","oss-fmi-value-route.time.simulation.label":"simulation time","oss-fmi-value-route.time.processing.label":"processing time","oss-fmi-value-route.time.validity.label":"validity time","oss-fmi-value-route.split.label":"calibration changes the mapping offset","oss-fmi-value-route.query.before.question":"Value as known before the calibration","oss-fmi-value-route.query.before.mapping":"mapping v3, offset 0.0","oss-fmi-value-route.query.after.question":"Value as known after the calibration","oss-fmi-value-route.query.after.mapping":"mapping v4, offset -0.6","oss-fmi-value-route.query.shared.chain":"answered from the same provenance chain","oss-fmi-value-route.band.left":"both answers come from the same chain","oss-fmi-value-route.band.right":"mapping version travels with the value","page-breadcrumb.c766e66518":"Breadcrumb","page-toc.7e439c353e":"On this page","section_st_a1_display-split.7c9a7c0610":"Detail","section_st_f1_cta-dark.90e40d5043":"Get started","toc-rail.f5cbdf6bfb":"Contents"}