How every card is checked before release

1. Headline

377 of BeidPrep's 456 card types are proven field by field by the OpenRadioss Starter itself: every value typed in the program is saved and then read back by the solver's own reader.

2. Summary

Before a card type can open as a form in BeidPrep, I type a distinct value into every one of its fields through the real panel, save the model with the program's own Save, and have today's OpenRadioss Starter read it back. At /BEGIN 2026, 377 of the 456 card types in the program have passed this for every field (3,156 proven fields in all). The card checks are 42 gates with 117 must-fail versions, inside a full regression of 503 gates and 808 must-fail versions that has to be clean before a release.

3. What is checked

The judge is the OpenRadioss Starter (build a62b27e6), not a printed guide and not BeidPrep's own templates. A guide can be wrong about columns, and a template written from it inherits the mistake. Only the solver's reader decides what the solver will actually use.

• Card types. The program knows 456 card types. Each field is proven separately, and each proof belongs to one /BEGIN version: 377 card types are fully proven at /BEGIN 2026, 212 at 2019 and 110 at 140. The proof records hold 365 keywords and 3,156 fields.
• The every-field write check. 248 case files, one per card type. Each one types every field, saves, and requires the Starter to read back exactly those values.
• The every-card edit check. One field is edited in each card family found in 19 real and synthetic decks, and the Starter has to read the edited save as it reads the unedited one. On the last run: 76 families, 51 edited and passed, 0 failed. The other 25 had no field that could be changed safely, and the program also says so.
• The save round trip. 32 decks are opened and saved without edits, and the result is compared byte for byte with the original: 32 of 32 identical.
• The rules around the proofs. Separate gates check that the program counts a proof correctly: an Engine card needs an Engine proof (a Starter echo is not enough), a field the solver ignores is marked and left out of the count, and two proofs of one keyword merge field by field.
• In total: 42 card gates with 117 must-fail versions.

4. How a test works, and what a pass means

For each card type and each /BEGIN version:

1. Control first. The Starter reads the unedited model with 0 errors and echoes its values. If this fails, nothing that follows can be trusted, so the check stops there.
2. Type every field in the real panel, with values that cannot be mistaken for each other or for a default: full-width numbers, every flag, every row of a repeated list.
3. Save with the program's own Save, the same code that File > Save runs.
4. Read back. The Starter reads the saved model with 0 errors, and each value it prints equals the value typed (integers exactly, reals to the 4 digits it prints).
5. Check the columns. Each value sits in exactly the columns the Starter's reader uses, to 1e-13. This is the full-precision half that the 4-digit echo cannot see.
6. Fields the Starter never prints. Such a field passes only if its text sits in the right columns and every printed neighbour on the same line reads back correctly in the same run.
7. Engine cards. The Starter never reads these, so a short Engine run checks what the Engine actually used or wrote.

What a pass means: at that /BEGIN version, the solver reads every value the user types into that card exactly as typed. Only then does the card type open as a form and become available for new cards. Any card type that has not passed opens as plain text, so the program never writes a field it cannot vouch for.

The must-fail versions. A check that has never failed proves nothing. Each card gate has deliberate breakages built in (117 of them in the card gates). One example is putting back the old /RBODY row layout from section 6. Every regression runs each of them, and every one has to make its gate FAIL. If a must-fail version passes, the regression fails, because a gate that can no longer fail has stopped checking anything. A proof record is written only from a run that passed and caught all of its must-fail versions.

5. When the checks run

• On every change. Any change to a card template is held back until the template contract check and the 32-deck save round trip pass. A quick source check (a few seconds) also confirms that every must-fail version is still listed and still reachable in the code.
• Nightly. The full regression, all 503 gates plus every must-fail version, runs on the machine at night.
• Before release. The whole regression has to be clean on the release build. The packaged program is also built and launched, and it has to open a model; a build nobody has launched is not a release build.

6. A real example: /RBODY's failure row

On 29 September I found a silent wrong write in /RBODY, the rigid body card. When the failure option is on, the card has a row with four values: FN, FT, expN and expT.

• What happened. The user typed expT = 4.5. BeidPrep followed the printed guide and wrote the row in 10-wide fields, so expT landed in columns 51-60. Today's Starter reads that row in 20-wide fields: expN in 41-60, expT in 61-80. Columns 61-80 were blank, so the Starter used its default and printed EXPT 2.000. No error, no warning. The model ran with a different failure exponent from the one the user typed.
• Why the existing checks missed it. The edit check changes one field per card on real decks, and no real deck turned that failure row on. The field was simply never exercised.
• The fix. The row now uses the Starter's own layout: FN 1-20, FT 21-40, expN 41-60, expT 61-80, all 20 wide.
• The proof. This is the case that created the every-field check. All 23 /RBODY fields were typed in the real panel with distinct values, saved, and read back by the Starter with 0 errors. The two fields the Starter never prints passed the neighbour rule. The must-fail version, which writes the old row, is caught: the Starter reads EXPT 2.000 again. /RBODY was the first card type with every field proven.

7. Limits: what the checks do not cover

• 79 card types are not fully proven at /BEGIN 2026. Older versions have fewer: 212 at 2019 and 110 at 140. These cards open as plain text. I can still edit them, but the program does not vouch for their columns.
• One Starter build. The proofs were made with OpenRadioss Starter a62b27e6. A later Starter that changes a reader would need the checks run again.
• Columns, not physics. A pass means the solver reads the value I typed. It does not mean the value is a sensible material constant or load. That stays the engineer's job.
• Fields the Starter never prints are proven indirectly: right columns plus correct neighbours. That is strong evidence, not a printed echo.
• Engine cards are proven only where a short Engine run can show the effect of the value.
• Decks. The edit check runs on 19 public and synthetic decks. 15 families that appear only in the largest deck are not edited in every run.
• Hand-written decks. A card the user types directly as text is saved as text. The checks cover what the program writes, not what is typed outside its forms.

Counts measured on BeidPrep build 6f106e86, 26 October 2026, with OpenRadioss Starter a62b27e6. Every model used is a public OpenRadioss example or a synthetic test model.