felupe-studio 0.6.0__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (90) hide show
  1. felupe_studio-0.6.0/.gitignore +20 -0
  2. felupe_studio-0.6.0/CHANGELOG.md +229 -0
  3. felupe_studio-0.6.0/LICENSE +674 -0
  4. felupe_studio-0.6.0/PKG-INFO +101 -0
  5. felupe_studio-0.6.0/README.md +70 -0
  6. felupe_studio-0.6.0/app/dist/assets/archive-EtgZMgZY.js +1 -0
  7. felupe_studio-0.6.0/app/dist/assets/client-7iqL7BQO.js +1 -0
  8. felupe_studio-0.6.0/app/dist/assets/client-Bue05veK.css +1 -0
  9. felupe_studio-0.6.0/app/dist/assets/files-mnN9zsH0.js +1 -0
  10. felupe_studio-0.6.0/app/dist/assets/main-CBztJLPH.js +115 -0
  11. felupe_studio-0.6.0/app/dist/assets/main-CiV2hAUy.css +1 -0
  12. felupe_studio-0.6.0/app/dist/assets/project-BAAuI0wz.js +10 -0
  13. felupe_studio-0.6.0/app/dist/assets/pyodide.worker-DGW69R0Q.js +7345 -0
  14. felupe_studio-0.6.0/app/dist/assets/schema-CduYFcoF.js +1 -0
  15. felupe_studio-0.6.0/app/dist/assets/spike-BYSp08uE.js +2 -0
  16. felupe_studio-0.6.0/app/dist/assets/spike-CZYcQnWM.css +1 -0
  17. felupe_studio-0.6.0/app/dist/index.html +17 -0
  18. felupe_studio-0.6.0/app/dist/spike.html +76 -0
  19. felupe_studio-0.6.0/app/dist/sw.js +59 -0
  20. felupe_studio-0.6.0/app/dist/version.json +1 -0
  21. felupe_studio-0.6.0/app/public/samples/bushing/bushing.py +54 -0
  22. felupe_studio-0.6.0/app/public/samples/bushing/model.felupe.json +260 -0
  23. felupe_studio-0.6.0/app/public/samples/bushing/thumbnail.svg +292 -0
  24. felupe_studio-0.6.0/app/public/samples/engine-mount/air.vtu +4680 -0
  25. felupe_studio-0.6.0/app/public/samples/engine-mount/metal.vtu +5861 -0
  26. felupe_studio-0.6.0/app/public/samples/engine-mount/model.felupe.json +219 -0
  27. felupe_studio-0.6.0/app/public/samples/engine-mount/rubber.vtu +10401 -0
  28. felupe_studio-0.6.0/app/public/samples/engine-mount/thumbnail.svg +2096 -0
  29. felupe_studio-0.6.0/app/public/samples/glued-plate/block.vtu +3799 -0
  30. felupe_studio-0.6.0/app/public/samples/glued-plate/model.felupe.json +155 -0
  31. felupe_studio-0.6.0/app/public/samples/glued-plate/thumbnail.svg +132 -0
  32. felupe_studio-0.6.0/app/public/samples/hex-tet-gmsh/bar.msh +1006 -0
  33. felupe_studio-0.6.0/app/public/samples/hex-tet-gmsh/model.felupe.json +106 -0
  34. felupe_studio-0.6.0/app/public/samples/hex-tet-gmsh/thumbnail.svg +196 -0
  35. felupe_studio-0.6.0/app/public/samples/hyperelastic-spring/model.felupe.json +194 -0
  36. felupe_studio-0.6.0/app/public/samples/hyperelastic-spring/spring.vtu +20292 -0
  37. felupe_studio-0.6.0/app/public/samples/hyperelastic-spring/thumbnail.svg +538 -0
  38. felupe_studio-0.6.0/app/public/samples/material-test/cube.vtu +486 -0
  39. felupe_studio-0.6.0/app/public/samples/material-test/model.felupe.json +59 -0
  40. felupe_studio-0.6.0/app/public/samples/material-test/thumbnail.svg +31 -0
  41. felupe_studio-0.6.0/app/public/samples/metacone/metacone.py +64 -0
  42. felupe_studio-0.6.0/app/public/samples/metacone/model.felupe.json +124 -0
  43. felupe_studio-0.6.0/app/public/samples/metacone/thumbnail.svg +464 -0
  44. felupe_studio-0.6.0/app/public/samples/plastic-plate/model.felupe.json +132 -0
  45. felupe_studio-0.6.0/app/public/samples/plastic-plate/plate_with_hole.py +40 -0
  46. felupe_studio-0.6.0/app/public/samples/plastic-plate/thumbnail.svg +132 -0
  47. felupe_studio-0.6.0/app/public/samples/plate-with-hole/model.felupe.json +114 -0
  48. felupe_studio-0.6.0/app/public/samples/plate-with-hole/plate_with_hole.py +40 -0
  49. felupe_studio-0.6.0/app/public/samples/plate-with-hole/thumbnail.svg +132 -0
  50. felupe_studio-0.6.0/app/public/samples/sandwich-spring/model.felupe.json +195 -0
  51. felupe_studio-0.6.0/app/public/samples/sandwich-spring/sandwich_spring.py +37 -0
  52. felupe_studio-0.6.0/app/public/samples/sandwich-spring/thumbnail.svg +232 -0
  53. felupe_studio-0.6.0/app/public/samples/sandwich-spring-axisymmetric/model.felupe.json +194 -0
  54. felupe_studio-0.6.0/app/public/samples/sandwich-spring-axisymmetric/sandwich_spring_2d.py +36 -0
  55. felupe_studio-0.6.0/app/public/samples/sandwich-spring-axisymmetric/thumbnail.svg +164 -0
  56. felupe_studio-0.6.0/app/public/samples/shear-mount/model.felupe.json +106 -0
  57. felupe_studio-0.6.0/app/public/samples/shear-mount/mount.vtu +5954 -0
  58. felupe_studio-0.6.0/app/public/samples/shear-mount/thumbnail.svg +164 -0
  59. felupe_studio-0.6.0/app/public/samples/two-materials/bar.vtu +3116 -0
  60. felupe_studio-0.6.0/app/public/samples/two-materials/model.felupe.json +119 -0
  61. felupe_studio-0.6.0/app/public/samples/two-materials/thumbnail.svg +116 -0
  62. felupe_studio-0.6.0/app/src/core/samples.json +183 -0
  63. felupe_studio-0.6.0/docs/commands.md +407 -0
  64. felupe_studio-0.6.0/docs/guide.md +299 -0
  65. felupe_studio-0.6.0/docs/reference.md +607 -0
  66. felupe_studio-0.6.0/hatch_build.py +40 -0
  67. felupe_studio-0.6.0/pyproject.toml +96 -0
  68. felupe_studio-0.6.0/python/felupe_studio/__about__.py +1 -0
  69. felupe_studio-0.6.0/python/felupe_studio/__init__.py +24 -0
  70. felupe_studio-0.6.0/python/felupe_studio/__main__.py +5 -0
  71. felupe_studio-0.6.0/python/felupe_studio/_helpers.py +361 -0
  72. felupe_studio-0.6.0/python/felupe_studio/benchmark.py +74 -0
  73. felupe_studio-0.6.0/python/felupe_studio/bridge.py +254 -0
  74. felupe_studio-0.6.0/python/felupe_studio/bytecode.py +42 -0
  75. felupe_studio-0.6.0/python/felupe_studio/checks.py +290 -0
  76. felupe_studio-0.6.0/python/felupe_studio/cli.py +67 -0
  77. felupe_studio-0.6.0/python/felupe_studio/codegen.py +1123 -0
  78. felupe_studio-0.6.0/python/felupe_studio/commands.py +716 -0
  79. felupe_studio-0.6.0/python/felupe_studio/commands.schema.json +2084 -0
  80. felupe_studio-0.6.0/python/felupe_studio/expressions.py +488 -0
  81. felupe_studio-0.6.0/python/felupe_studio/loadcases.py +138 -0
  82. felupe_studio-0.6.0/python/felupe_studio/materials.py +187 -0
  83. felupe_studio-0.6.0/python/felupe_studio/mcp.py +727 -0
  84. felupe_studio-0.6.0/python/felupe_studio/meshes.py +270 -0
  85. felupe_studio-0.6.0/python/felupe_studio/project.py +205 -0
  86. felupe_studio-0.6.0/python/felupe_studio/results.py +785 -0
  87. felupe_studio-0.6.0/python/felupe_studio/runner.py +424 -0
  88. felupe_studio-0.6.0/python/felupe_studio/runtime.py +334 -0
  89. felupe_studio-0.6.0/python/felupe_studio/scene.py +126 -0
  90. felupe_studio-0.6.0/python/felupe_studio/serve.py +316 -0
@@ -0,0 +1,20 @@
1
+ # Node
2
+ node_modules/
3
+ dist/
4
+
5
+ # Python
6
+ __pycache__/
7
+ *.py[cod]
8
+ *.egg-info/
9
+ .pytest_cache/
10
+ .ruff_cache/
11
+ build/
12
+ .venv/
13
+
14
+ # Editors and OS
15
+ .vscode/
16
+ .idea/
17
+ .DS_Store
18
+
19
+ # Downloaded by app/scripts/fetch-wheels.js
20
+ app/public/wheels/
@@ -0,0 +1,229 @@
1
+ # Changelog
2
+
3
+ All notable changes of FElupe Studio (the web app and the Python package `felupe_studio`, released together with the same version).
4
+
5
+ ## [0.6.0] - 2026-11-19
6
+
7
+ A local Python runtime, the agent bridge, large models and expressions of parameters:
8
+ - **Python on your computer:** `felupe-studio serve` runs the same app with the Python of your computer instead of Pyodide (ADR 0014), and the package with the built app is on PyPI.
9
+ - **Agents on the open app:** with `felupe-studio serve --agent`, an agent like Claude Code works on the model that is open in a tab (ADR 0015). Its changes are steps of the history, and its mesh scripts run only after the user agrees.
10
+ - **Expressions of parameters:** the numbers of the commands may be expressions of the parameters, e.g. `0.5 * layers * height` (ADR 0013).
11
+ - **Large models:** single precision of the linear equation system of a job, or of the whole model with an estimate of its round-off (ADR 0016), and a bytecode cache that halves the FElupe step of the start in the browser (ADR 0017).
12
+ - **Touch screens:** a long press picks like Shift+click.
13
+
14
+ The schema version stays 3: projects of v0.5 open unchanged, and the new options are additive (expressions in number fields, `precision` of `model.settings` and of the solver of a job). FElupe 12.1.1, Pyodide 314.0.7.
15
+
16
+ ### Added
17
+
18
+ - A model in single precision (ADR 0016): *Precision* of the *Model settings* (`model.settings.precision`: `double` or `single`) builds the regions, the fields, the stresses and the linear equation system in `float32`, in half the memory. The script has `DTYPE = np.float32`, the regions `.astype(DTYPE)` and the fields `dtype=DTYPE`. As the accuracy of single precision depends on the model, the job panel shows an estimate of the round-off of the forces relative to the reaction forces, e.g. *round-off 0.65 % of the reaction forces*. From 1 % on it warns and suggests double precision, e.g. for steel bonded to rubber (the sandwich spring: 43 %, its curve deviates by 4 %). The curves deviate from double precision by about a tenth of the estimate, or by the tolerance of the job if that is larger: within 1e-3 for the golden cases and the samples with an estimate below 1 %, except the elastic-plastic plate (2e-3 at its tolerance of 0.01, 3e-5 at 1e-6). Elastic-plastic materials keep the linear equation system in double precision (their tangent of FElupe), and the friction block does not converge in single precision. The benchmark of the spike (`spike.html`) runs the model in single precision too: in CPython, a cube with 14,739 DOF solves in 9.9 s instead of 28 s, in 188 MB instead of 317 MB (#297).
19
+ - A bytecode cache of Pyodide (ADR 0017): the worker keeps the bytecode of the imported modules (NumPy, SciPy, FElupe, meshio, tensortrax, `felupe_studio`) in IndexedDB and reads it at the next start, instead of compiling about 740 modules again. The FElupe step of the start takes about half the time from the second start of a version on: 3.9 s → 1.6–1.8 s in Chromium on a desktop. The first start fills the cache in the background; a new version starts a new cache and removes the old one. The cache is optional: without IndexedDB (e.g. in a private window) the start is as before. `spike.html` lists the parts of the FElupe step (wheels, NumPy and SciPy, FElupe, meshio) and the state of the cache (#49).
20
+ - The linear equation system of a job in single precision (ADR 0016): *Precision* of a direct solver (`solver.precision`: `double` or `single`) solves the linear system of every Newton iteration in `float32`, with the model, the residual forces and the convergence check in double precision. The curves are those of double precision (within 2e-5 for the golden cases and the samples), with up to a quarter less memory and up to two times faster for large models. The script wraps the solver, `solver=single_precision(fem.solve.SuperLUSolver())`; the job panel says *SuperLU, single precision*. The Pyodide benchmark (`spike.html`) runs in both precisions (#152).
21
+ - `felupe-studio serve --agent`, the server side of the agent bridge (ADR 0015): an MCP endpoint at `/mcp` (Streamable HTTP, the token as `Authorization: Bearer`, no browser origins) whose tools act on the model of one connected tab of the app, which answers them over the WebSocket `/agent`: the tools of the MCP server (`list_commands`, `add_command`, …, `solve` with progress, `results`) and `selection`, `select`, `show` and `picture`. It prints the command that adds it to Claude Code (#258).
22
+ - The agent bridge in the app: *Help ▸ Connect an agent* connects the tab of `felupe-studio serve --agent`, and the app answers the tools of the agent on the open model: each change is an undo step with the issues of the app, `solve` runs the app's Solve with its live results and reports the progress, `show` and `picture` give the agent the view, `select` and `selection` the selection of the user. A mesh script of the agent runs only after the user agrees (*Show the script*, *Run it*). `check` runs the checks of the mesh data in the local runtime. The status bar shows the connection with *Disconnect* (#258).
23
+ - `felupe-studio serve`, the server of a local Python runtime (ADR 0014): it serves the built app on `127.0.0.1` and runs the Python side with the CPython of the computer, with the messages of the Pyodide worker over a WebSocket (binary frames for the arrays), one Python process with a temporary folder per connection (closing it ends a running job), a token in the URL and only the hosts and the origin of the loopback interface. It needs `pip install "felupe-studio[serve]"`; the wheel has the built app (without the files of Pyodide) and serves the samples of the package (#240).
24
+ - The app of `felupe-studio serve` uses the local Python: the same requests over the WebSocket, typed arrays like from the worker, *Cancel* by a new connection (a new process). The status bar says *FElupe 12.1.0 ready, local Python 3.13 (0.5 s)*, *About* lists the runtime and its versions and reports a package of another version than the app. Opening a project with mesh scripts shows them before they run, also without parameters: they run on this computer with your rights. No service worker; the token of the link is kept for the tab, so a reload works (#240).
25
+ - Expressions of parameters in the numbers of the commands (the core, ADR 0013): a number field holds a number or an expression as a string, e.g. `"end": "0.5 * layers * height"` or `"value": "height"`, with numbers, the parameters, `pi`, `+ - * / **`, parentheses and `sqrt exp log sin cos tan abs min max`. The schema gives these fields the types `["number", "string"]`; the fields of `parameter.add`, the tag of a cell set, the ids of a point set and the decimals of the merge stay numbers. Python and the app evaluate an expression with the same parser and the same messages (shared cases), e.g. *'layer' is not a parameter in '0.5 * layer * height'*, *'cells / 3' is 1.3333333333333333, not an integer* or *'1 - cells' is -3, it must be at least 1*; the validation reports them first and checks the other rules with the values. The script shows an expression as written, e.g. `fem.math.linsteps([0, (0.5 * layers * height)], num=(2 * cells))`. The viewer, the validation and the runs of the app use the values, the browser shows the expressions; renaming a parameter renames it in the expressions. A golden case is the sandwich spring with expressions (#242).
26
+ - Expressions in the forms: a number field takes an expression of the parameters (a leading `=` is fine) and shows its value with its unit below it, e.g. *= 12 mm*, also in the rows of a ramp; a list of numbers takes expressions separated by commas, e.g. `0, 0, height`. The form checks an expression with the values of the parameters and its value against the range of the field, e.g. *'1 - cells' is -3. Must be at least 1.* In a model with parameters, these fields have a text keyboard on touch screens. The issue of a stored expression is shown at its field, also in a row. The dialog of the parameters says which objects use a parameter and warns of the problems of the expressions with the typed values, e.g. too few increments (#242).
27
+ - `felupe-studio` on PyPI: `pip install "felupe-studio[mcp]"` installs the Python package and the MCP server without a clone. A tag `vX.Y.Z` publishes it by a release workflow with trusted publishing (no token): it checks that the tag is the version, builds the sdist and the wheel, checks the wheel in a fresh environment outside of a clone, and uploads them. The wheel contains the samples and the documents of the MCP server (its resources), so `open_sample` works outside of a clone too; a clone still uses its own folders, and `FELUPE_STUDIO_SAMPLES` another one. The README on PyPI has absolute links to GitHub. CI builds and checks the wheel on every push (#275).
28
+ - A build without the built-in samples: `BUILT_IN_SAMPLES=false` (with `EXTRA_SAMPLES_DIR`, e.g. for a deployment with only private samples) leaves them out of the app and of the build output; the extra samples are then the samples, without the section *More samples*. Without any samples, the welcome panel has no samples and *File ▸ Samples…* is gone. Without the parameter, the build is unchanged (#279).
29
+ - A long press picks like Shift+click: hold the pointer still for half a second to cycle a single face or to add a node, also on a touch screen without Shift. A ring at the pointer shows it; a drag (a rotation) or a second finger cancels it. On a touch screen the hints speak of taps and long presses, e.g. *Long-press single faces* and *tap again to exclude* (#273).
30
+
31
+ ### Changed
32
+
33
+ - The sample *Sandwich spring with parameters* shears by an expression of the parameters, half of the height of the soft layers (`0.5 * layers * height`, 12 mm for 3 layers), in `2 * cells` increments: with 5 layers it shears by 20 mm to the same shear strain. The guide, the README and the release checklist describe version 0.6, with new screenshots of the expressions and of an agent on the open app; `docs/make_screenshots.py --pyodide <folder>` serves Pyodide from a folder if its CDN is not reachable (#276).
34
+ - FElupe 12.1.1 (the wheel of the app, the golden tests and `felupe>=12.1.1` of the package). It imports `scipy.interpolate` and `scipy.special` only when they are used (adtzlr/felupe#1297), so `import felupe` in Pyodide takes 0.4 s instead of 1.2 s without the bytecode cache and 0.1–0.2 s instead of 0.4 s with it (Node). It also has the fixes for a model in single precision: a region keeps its precision after `field.merge()` (adtzlr/felupe#1293), and the default absolute tolerance of the Newton-Raphson method in single precision (adtzlr/felupe#1294). The curves of the golden cases are unchanged.
35
+ - The MCP server refuses a command with the name of another one (*Not added: there is already an object 'right'.*) and a rename to an existing name, like the agent bridge of the app; before, it added it and the validation reported it. Shared cases check that both give the same answers (#258).
36
+ - Values at the points: the strain and the stress tensors are moved to the points, and their principal values and the von Mises stress are evaluated there, instead of moving the invariants of the quadrature points. So the von Mises stress is never negative, e.g. next to the air of the engine mount (it was down to -0.27 MPa projected), and the principal values are those of the tensor at a point. The equivalent plastic strain is clipped at zero. The values at the cells are unchanged (#274).
37
+
38
+ ### Fixed
39
+
40
+ - The sample *Elastic-plastic plate with a hole* did not solve in the browser: in Pyodide, the Newton iterations of the tenth substep of the loading did not converge (the spreading yield zone is sensitive to the round-off, which differs from CPython). Its job cuts back a substep that does not converge now, and the curve is the same within the tolerance of the job.
41
+ - A form with an error in a row, e.g. in the end value of a ramp, is not applied; it was applied before, and the validation reported the value (#242).
42
+
43
+ ## [0.5.0] - 2026-11-18
44
+
45
+ Plasticity, results at the points, samples and an agent interface: the strain-based materials of FElupe 12.1 (`fem.MaterialStrain`) bring linear elasticity and von Mises plasticity with isotropic hardening, in small strain or in a framework of large deformations, with the state variables of every substep in the results (the sample *Elastic-plastic plate with a hole*). The strains and the stresses are shown at the cells or smooth at the points of the meshes, also in the exports. Two samples come from the FElupe examples: the engine mount ex07 with air as a third medium (`u-isochoric`) and the metacone ex15. An MCP server lets AI agents build, check and solve models headless in CPython (ADR 0012). The material models are in three menus by their kind, and surfaces are picked by clicks and taps without a right click. The schema version stays 3: projects of v0.3 and v0.4 open unchanged, and the new commands and options are additive (the strain-based models with `framework` and `strain_exponent`, `LinearElasticSmallStrain`, the formulation `u-isochoric`, point sets of a section, a value per component of a boundary). FElupe 12.1.0.
46
+
47
+ ### Added
48
+
49
+ - Documentation of v0.5: the README and the user guide describe the elastic-plastic materials, the values at the points, the samples of v0.5, the MCP server and the limits of version 0.5; screenshots of the engine mount and of the plasticity, and the release checklist with the smoke tests of v0.5 (#264).
50
+ - The sample *Elastic-plastic plate with a hole*: the quarter of the plate with a hole in plane strain in steel (*Elastic-plastic, isotropic hardening*, small strain), pulled by 0.1 mm beyond its yield stress and back to the start. The stress at the hole yields first; the curve unloads elastically, crosses zero force at the remaining elongation and yields again in compression; the contour of the equivalent plastic strain shows the plastic zone (#269).
51
+ - The material model *Linear elastic (small strain)* (`LinearElasticSmallStrain`, `fem.LinearElastic` with E and ν): the stress of the symmetric part of the displacement gradient, for small displacements and rotations. A golden case pulls a cube of it: the force is E u, the one of the strain-based linear elastic model in small strain (#259).
52
+ - Extra samples from a folder at build time: `EXTRA_SAMPLES_DIR=~/my-samples npm run build` (or `npm run dev`) adds the samples of a folder outside the repository, e.g. private ones, one folder per sample with its `model.felupe.json`, its mesh files or scripts and optionally `thumbnail.svg` (else a placeholder), and optionally a `samples.json` with titles, descriptions, topics and the order. *File ▸ Samples…* and the welcome panel show them in their own section *More samples*. Errors (a missing folder, project file or mesh file, an invalid project, an id of a built-in sample) fail the build. Without it, the build is unchanged. See `CONTRIBUTING.md` (#255).
53
+ - An MCP server for AI agents (`felupe-studio-mcp`, the optional dependency `felupe-studio[mcp]`): agents like Claude Code or GitHub Copilot build, check and solve models with its tools (the schema of the commands, samples, projects, commands with the issues of the validation, mesh files and scripts, checks, the script, solve with progress, results and exports), headless with CPython; the saved project opens in the app. Mesh scripts run only if the server wrote them or with `--allow-scripts`. See [AI agents](docs/agents.md) and ADR 0012 (#239).
54
+ - The frameworks *Co-rotational* (the Biot strain of the stretch) and *Seth-Hill* with a *Strain exponent m* (e.g. 0 for the logarithmic Hencky strain) of the strain-based materials, from FElupe 12.1 with exact tangents. The package needs `felupe>=12.1.0` (#191).
55
+ - The sample *Engine mount (FElupe ex07)*: rubber between an inner and an outer metal part in plane strain, with air in its cavities, on the meshes of ex07. The job `vertical` moves the inner part by 3 mm in y, the job `horizontal` then by 8 mm in x, there and back; the vertical force equals the one of ex07 (#241).
56
+ - The formulation `u-isochoric` of a section (*Displacement, isochoric part only (third medium)*): a material without a bulk modulus as it is, without a volumetric part, e.g. air as a third medium in the cavities of a rubber part (#241).
57
+ - Point sets *Of a section*: all points of the cells of a section, e.g. of a rigid part whose points are all moved by boundaries (#241).
58
+ - The sample *Metacone (FElupe ex15)*: a conical rubber-metal spring as an axisymmetric model, two rubber layers between three steel sheets, its section made by a mesh script like ex15 (runouts, rotated to the cone) with the thickness of the sheets and the fineness as parameters. The clamped uniaxial load case pushes the end of the inner sleeve along the axis; the force equals the one of ex15 (#241).
59
+ - Strain-based materials (`fem.MaterialStrain`, the menu *Strain-based elasticity ▾* of the Materials): *Linear elastic* and *Elastic-plastic, isotropic hardening* (von Mises plasticity with linear isotropic hardening, FElupe's `linear_elastic_plastic_isotropic_hardening`), in the framework *Small strain* (default) or *Total Lagrange*. The parameters are E and ν (the script converts them with `fem.constitution.lame_converter` into λ and μ), the yield stress σy and the hardening modulus K; the defaults are a steel in MPa. A section with a strain-based material needs the formulation `u` (validation). The results record the state variables of every substep, so the stresses of a substep are those of its state, and show the *Equivalent plastic strain* as a contour (also in the VTU and XDMF exports). A golden case pulls a cube of steel beyond its yield stress and unloads it: the curve and the remaining strain agree with the analytical ones of linear hardening (#191).
60
+ - *Values at* in the contour settings of the Results: the strains and the stresses at the cells (the mean of the quadrature points of every cell, the default) or at the points, as a smooth contour: the means of the cells averaged at the points, projected (`fem.project`, an L2 projection, closer to the peaks, e.g. at a hole) or shifted (`fem.topoints`, for hexahedrons and quads; other cells are projected instead). Per section, discontinuous between sections. The range over all substeps, the live scenes and the export of the results take the choice; the VTU and XDMF files get the strains and the stresses as point data too, the means of the sections at their common points. Kept in the browser (#231).
61
+ - *Edges* in the toolbar of the Results view, beside *Nodes*: the contour with or without the edges of the cells on the deformed shape (on by default), kept for the next run and in the exported picture (#233).
62
+ - A boundary prescribes one value for all of its constrained components or one per component, in the order x, y, z, e.g. `0.5, -0.1` for x and z: `fem.Boundary(..., value=[0.5, -0.1])`, so one boundary moves a point set diagonally. The start and end of its ramp in a step are one value or one per component too (`np.linspace(start, end, num + 1)` in the script). The form takes the values separated by commas; the validation checks their count against the constrained components; the viewport draws the arrow in their direction (#225).
63
+ - *Export mesh…* in the menu of a mesh in the browser: the mesh as the model uses it, also the mesh of a script with the current parameters (and its item), as a file of another format: VTK unstructured grid (`.vtu`, the default), VTK legacy (`.vtk`), Gmsh (`.msh`), Abaqus (`.inp`) or Nastran (`.bdf`), written by meshio with the solid cells and their tags, the points in 3D and scaled like the model. A mesh with an error or without Python says why it cannot be exported (#230).
64
+
65
+ ### Changed
66
+
67
+ - Picking surfaces without a right click, e.g. on a phone or a tablet: a click (or a tap) cycles the state of the clicked surface, picked → excluded → not picked, and a fourth click picks it again; Shift+click cycles a single face the same way (a face of a picked surface is left out, as before). The panel says what the next click does, e.g. *click again to exclude*. A right click stays a shortcut that deselects a picked or excluded surface at once. The toggle *Exclude* of the panel is gone. A click on a picked node deselects it (#260).
68
+ - The material models are grouped by their kind in three menus of the ribbon, also in the choice of the model in the properties: *Linear elasticity* (small strain, large strain), *Hyperelasticity* (Neo-Hooke, Neo-Hooke compressible, Mooney-Rivlin, Yeoh, third-order deformation, Ogden, Arruda-Boyce, extended tube; FElupe classes and functions of tensortrax alike) and *Strain-based elasticity* (linear elastic, elastic-plastic). The definitions of `material.add` in the schema are in the order of the menus, so a new material without a model starts with *Linear elastic (small strain)*. The descriptions no longer say *needs tensortrax*. Annotations only: projects stay valid, the schema version stays 3 (#259).
69
+ - FElupe 12.1.0 (the wheel of the app and the reference of the tests, `FELUPE_VERSION` of the CI; the WebGL viewer is unchanged). Its Newton-Raphson method checks the convergence relative to a reference force, the reaction forces or the forces between the items if they are larger (e.g. of a pressure or a contact on a solid body), with an absolute tolerance at the round-off errors instead of 0.001: a job with the default tolerance may take fewer iterations. The curves of the golden cases agree within 1e-8, except `block_pressure` with the default tolerance: its forces change by up to 0.7 % of the largest force, and both versions deviate by less than 1 % of it from the converged curve.
70
+ - The `u-p-J` formulation of linear hexahedrons and quads uses `fem.SolidBodyNearlyIncompressible` on the displacements only, which condenses the constant pressure and volume ratio of every cell, instead of the mixed fields `fem.FieldsMixed` with `fem.NearlyIncompressible`. The discretization is the same: converged results agree within 1e-9. The system has about a third fewer unknowns. At the default tolerance a job may take a few more Newton iterations but ends closer to the converged result (see `docs/benchmarks.md`). Other cells (tetrahedrons and triangles with the MINI element, quadratic cells) keep the mixed fields. The generated script has the helpers `mixed_field()` and `nearly_incompressible()` (only with a `u-p-J` section), so `mixed_field`, `nearly_incompressible` and the other names of the helpers are reserved (#226).
71
+ - The sample *Material test: uniaxial tension* has the tolerance 1e-6, for its comparison with the analytical curve.
72
+
73
+ ### Fixed
74
+
75
+ - The curve of a job and the values in the results header show by default the component whose displacement changes most over the substeps, not the largest one of the last substep: a job that moves there and back, e.g. the job `horizontal` of the engine mount (FElupe ex07), shows Fx over ux instead of Fy over uy (#266).
76
+
77
+ ## [0.4.0] - 2026-11-13
78
+
79
+ Parameters, 2D models and contact: a project gets model parameters with units, asked for when it is opened, and its meshes can be made by Python scripts with them (the parametric sandwich spring and the bushing of FElupe's example ex05). Models are 3D, plane strain or axisymmetric (ADR 0010). Rigid planes and cylinders touch the points of a model by contacts with friction (ADR 0011; the spring with end stops of FElupe's example ex06). Symmetry planes are objects of their own, a running job shows its results live, the curve has free axes, a job chooses its linear solver, and the default tolerance of the Newton-Raphson method is 0.01. The schema version stays 3: projects of v0.3 open unchanged, and new commands are additive (`parameter.add`, `mesh.script`, `symmetry.add`, `rigid.add`, `contact.add`, `analysis` of `model.settings`). Projects of schema versions 1 and 2 are migrated when they are opened.
80
+
81
+ ### Added
82
+
83
+ - Documentation of v0.4: the README and the user guide describe parameters and mesh scripts, 2D models, symmetry planes, rigid surfaces and contacts and the limits of version 0.4; new screenshots of the parameters of the sandwich spring, the plate with a hole in plane strain and the spring with end stops (`docs/make_screenshots.py`); the release checklist has smoke tests of them (#235).
84
+ - Sample *Hyperelastic spring with end stops (FElupe ex06)*: a half of the spring of the example ex06 of FElupe bonded to two plates, compressed and then sheared by the lower plate. The plates are end stops, rigid planes with contacts with friction of the points on the outer surface; the bulging spring touches the upper one. Its test compares the forces with ex06 on the same mesh (within 1e-3). ADR 0011 records the rigid surfaces and contacts; docs of the guide and the commands (closes #222, closes #187).
85
+ - Point sets on the outer surface (*On the outer surface*, `select: {surface: true}`): the points of the faces of the meshes of the sections that belong to one cell (of a 2D model of the edges), e.g. the points of a contact. Faces between two sections are inside; the script takes them with `surface_points` (#222).
86
+ - *Back and forth* (⇄ beside ▷) for playing the substeps in the Results: after the last substep backward to the first one and forward again (the ends are shown once), instead of the loop (after the last substep the first one). The scenes loaded ahead follow the direction of playing.
87
+ - Contacts in 2D models: a rigid plane is a line in the xy-plane and a cylinder a circle about z (`fem.ContactRigidCylinder` without an axis). Golden cases: a plate in plane strain and a cylinder (axisymmetric) pressed at their end by a line, compared with a prescribed displacement, and a roller pressed onto a plate (#221).
88
+ - Contacts with rigid surfaces (`contact.add`): the points of a face set or a point set touch a rigid plane or cylinder (`fem.ContactRigidPlane`, `fem.ContactRigidCylinder`) with friction, a multiplier of the penalty and an elastic slip; the penalties follow the stiffness of the sections. Contacts are items of the steps like the constraints; the curve of a boundary of the surface is the contact force. Golden cases: a block pressed by a plane without and with friction, compared with a prescribed displacement, and a roller pressed onto a block (#220).
89
+ - Rigid surfaces (`rigid.add`): a plane or a cylinder through a reference point, which is a vertex like the control points and moved by boundaries. The viewport draws them as translucent shapes (in 2D models as lines and circles), also moved in the results; the reference points are in the results of the control points (#219).
90
+ - 2D samples: an axisymmetric sandwich spring pressed along its axis and a plate with a hole in plane strain, both made by mesh scripts with parameters; ADR 0010 records the conventions of 2D models (closes #175).
91
+ - Control points and multi-point constraints in 2D models, in the xy-plane: a rotation point turns the connected points about z in plane strain (a boundary of it constrains z, the rotation about z; a point load at it is a moment about z), and its curve and results show φz and Mz like in 3D. The new forms of boundaries and constraints of a 2D model constrain x and y. Golden case: a plate turned by a rigid end, compared with the 3D bar with fixed z (part of #175).
92
+ - Face sets and pressures in 2D models: the face sets are edges of quads (linear or quadratic), on a line or picked in the viewport, with the boundary regions of quads of FElupe; a pressure on them is per unit thickness (plane strain) or over the circumference (axisymmetric). The viewport draws the edges as strips and the pressures as arrows normal to them. Golden case: an axisymmetric cylinder of quadratic quads pulled by a pressure (part of #175).
93
+ - 2D models: *Analysis* in the model settings makes a model *Plane strain* (forces per unit thickness) or *Axisymmetric* (x is the axis of rotation, y the radius, forces over the circumference) with a mesh of triangles or quads (linear or quadratic) in the xy-plane. The script takes `fem.FieldPlaneStrain` or `fem.FieldAxisymmetric` (mixed fields with `planestrain=True` or `axisymmetric=True`, the MINI element for linear triangles) and boundaries, point loads, symmetry planes and load cases in x and y. The validation reports z components, 3D cells in a 2D model and 2D cells in a 3D model; the viewport opens a 2D model onto the xy-plane. Golden cases: a plane strain plate and an axisymmetric cylinder, compared with the analytical force; the check of interfaces takes the edges of 2D cells (part of #175).
94
+ - Watch a running job live in the Results: the deformed model with the contour of the last converged substep (throttled to at most about a tenth of the time of a job, the last substep of every step always) and the curve growing with every substep, marked *Live · substep 7 of 20*. *Show live results* in the job panel opens it; after a failed or cancelled run, the last live scene and the curve stay until the next run. *Live results* in the Results ribbon turns the scenes off. The choices of the Results view, e.g. the quantity, are kept for the next run (#207).
95
+ - Rename the project: a click on its name in the header (or *File ▸ Rename project…*) turns it into a field; Enter renames, Escape cancels, the format stays. The next save, the exports and the session take the new name; the project is not saved until it is saved under it (#205).
96
+ - A selectable linear solver of a job: *SuperLU (FElupe)* (the default), *spsolve (SciPy)* or an iterative method of SciPy (minres, cg, gmres, bicgstab) with a relative tolerance of the job's tolerance / 100 by default, or a given one, and an optional maximum of iterations. An iterative method that does not converge fails the job with a message. The script writes `solver=...` to `job.evaluate()`, with the helpers only when used; the browser and the job panel show the solver. A golden case with minres (#203).
97
+ - A more flexible curve: *x* and *y* in the curve card choose the quantity of each axis among the components of the displacement and of the force of the curve boundary (of a rotation point the rotation and the moment) and the substep, e.g. uy over ux or Fz over the substep. *Axes* sets per axis a linear or log scale, negated values and a fixed range, kept in the browser. The title, the labels, the table and the values in the results panel follow the axes (#197).
98
+ - Symmetry planes: *Symmetry* (`symmetry.add`) in *Loads & BCs* makes symmetry planes normal to x, y or z at their coordinates (default 0) with `fem.dof.symmetry`, boundaries of all steps, for a half, a quarter or an eighth of a model without a load case. The form shows the coordinates of the chosen planes; the browser lists it with the boundaries (`x = 0, z = 0`); the viewport draws its planes and warns about a plane without nodes. A plane that a load case or another symmetry already has is noted, not an error. A golden case: a quarter of a clamped bar has a quarter of the force of the full bar (#186).
99
+ - Combine picked surfaces like `Mesh.select_surface_points()` of FElupe: further clicks add the surfaces of other faces (also of other sections), a right click deselects a surface and a second one excludes it, drawn dark red. The points of excluded surfaces are removed from the selection, e.g. an edge shared with an excluded neighbour. Shift+click adds or removes single faces of a picked surface (Shift+right-click excludes one), *Exclude* in the panel makes taps act as right clicks on touch screens, a click beside the model keeps the picked surfaces. The panel counts them, e.g. *3 patches · 1 excluded · 54 faces of body · 66 points*; *Create face set* needs faces of one section. Two sides of a box are no longer described as a cylinder (#195).
100
+ - The sample *Bushing with steel sleeves (FElupe ex05)*: a hyperelastic body between two steel sleeves made by `bushing.py`, with the lengths, the sleeve thickness, the runout and the fineness of the mesh as parameters, point sets on cylinders and a rigid connection of the inner sleeve with a rotation point (radial, torsion and tilt). Its moment of the torsion agrees with ex05 within 0.1 %. A coarse golden case (#185).
101
+ - The sample *Sandwich spring with parameters*: hyperelastic discs between steel sheets, sheared by the top sheet, with a mesh made by `sandwich_spring.py` from the parameters radius, layers, height, sheet, cells and cells_height (the cells through a soft layer; one cell through a sheet), and point sets at the bounds of the meshes; the top sheet is guided by `guide_y` and `guide_z`, so a ramp of `guide_z` compresses it. Golden cases with 3 and 5 layers (#184).
102
+ - The parameters of a project: opening a project with parameters shows their values first, with their units and a slider for a range; *Open* applies the changed values as one undo step before the meshes of scripts are made, *Keep the saved values* skips them. The dialog says which Python scripts the project runs and shows them. *All parameters…* in the menu of a parameter opens it later (#183).
103
+ - A click on an object in the browser in the Results workspace shows its properties in the Model workspace; a click on a job with results shows its results instead. *Results* keeps the view (#196).
104
+ - Meshes made by scripts: *Mesh script* (`mesh.script`) runs a Python script next to the project with the parameters of the model as variables and takes its `mesh`, a `fem.Mesh`, a `fem.MeshContainer`, a `meshio.Mesh` or an item of a dict of meshes (e.g. `soft` and `metal`). The script is kept like a mesh file (also in archives); a changed parameter makes the mesh again in the worker; an error of the script is an issue of the mesh with its traceback in the properties. Opening a script alone starts a new mesh script with it. The generated script runs it with `run_mesh_script()` (#182, ADR 0009).
105
+ - Pick connected surfaces by a feature angle: a click on a face of a section picks the faces reached over shared edges while the normals of neighbouring faces differ by at most the *Angle* of the panel (30° by default, 10° to 180°, kept in the browser), e.g. a whole cylindrical sleeve. The panel says what was picked (*Plane z = 20 (max)*, *Cylinder r = 25 about x*, *Surface*) and stores the simplest selection that selects exactly the picked surface: the plane or its bound, the cylinder, or else the nodes (point set) and the centers of the faces (face set). Shift+click adds or removes single faces (#189).
106
+ - Point sets at a bound of the meshes and on a cylinder: *At a bound* (`select: {bound: "max", axis: "z"}`) selects the points at the smallest or largest coordinate of the meshes of the sections, without the control points, so that the top of a model stays selected when its mesh changes; *On a cylinder* (`select: {radius, axis, center}`) the points at a distance from an axis parallel to x, y or z, e.g. a sleeve of a bushing. A picked plane at a bound of the meshes creates a point set at the bound (`z == max`). The viewport marks their points and warns about a plane, bound or cylinder without points (#181).
107
+ - Parameters of the model: `parameter.add` is a named number with an optional quantity (length, force or stress, with the unit of the model settings), a range, a step, *Integer* and a description. The *Mesh* tab has a *Parameter* button next to *Model settings*; the browser lists the parameters below the settings with their value and range; a value outside of its range and fractions of an integer parameter are issues. The script defines them as variables at its top (`radius = 50.0 # mm`). The first step of parametric projects (#154): meshes made by scripts use them next (#180).
108
+
109
+ ### Changed
110
+
111
+ - The curve of a job shows by default the force over the displacement of the component with the largest displacement; of equal displacements now the one with the largest force, e.g. the axial force of a spring that is compressed and then sheared by as much (#222).
112
+ - The word *rubber* is gone from the app: the samples, their descriptions, their objects and their scripts speak of hyperelastic materials and soft layers (*Mount in shear*, *Hyperelastic block with a rigid plate*, *Bushing with steel sleeves*; the sample `rubber-mount` is now `shear-mount`), and so do the hints, the help of the command line and the guide.
113
+ - The default tolerance of the Newton-Raphson method is 0.01 (FElupe's default is 1.49e-8), like the force criterion of commercial codes: the norm of the residual forces relative to the norm of the reaction forces. The generated script always passes it (`job.evaluate(x0=field, tol=0.01)`), the form shows it as the placeholder. In the golden cases a job takes about half the time, and the forces deviate by less than 1 % of the largest force. Projects without a tolerance are not migrated: their results change slightly; set *Tolerance* to e.g. 1e-6 for curves that are fitted to test data. The golden cases compared with converged references set `tol: 1.49e-8` (#176).
114
+
115
+ ### Fixed
116
+
117
+ - The validation counts a boundary of a point set by a plane, by nodes or on a cylinder through a control point or the reference point of a rigid surface: the script constrains them with the point set, e.g. a rigid plane whose reference point is on the plane of a bonded face, which was reported without stiffness (#222).
118
+ - A mesh script without items, e.g. of the sample *Plate with a hole*, failed in the app with *The mesh of 'plate_with_hole.py' is not a dict with an item jsnull*: the worker passed JavaScript's null, which Pyodide converts to `jsnull`, not to None.
119
+ - *Save project as…* refuses a name of an archive whose script would have the name of a mesh script of the project, e.g. `bushing` with the script for the sample *Bushing with steel sleeves*, instead of failing with two files `bushing.py` (#205).
120
+ - *Iso* (key 1) resets the camera to the default view, in which the viewer opens (like the plots of FElupe, onto the xy-plane for a planar model), instead of the isometric view.
121
+ - The labels of a dialog that creates an object point to its own fields: with an object selected, the properties and the dialog had fields of the same ids, so a click on a label of the dialog focused the field of the properties (#181).
122
+ - The contour settings: the selects stay inside the popover (they took the width of their longest option), the popover is wide enough for *Cool–warm (centered at 0)* and stays inside the window (#177).
123
+
124
+ ## [0.3.0] - 2026-11-12
125
+
126
+ Settings, results display, project archives and pressures: the units of a model, more material models (tensortrax), the settings of the solver in the properties, contour settings with the minimum and maximum of a contour and playing the substeps, project archives (`.felupe.zip`) with Save as, face sets and pressures. Projects of schema versions 1 (v0.1) and 2 (v0.2) are migrated when they are opened; projects saved with v0.3 have schema version 3. Archives are plain ZIP files with the project file, its mesh files and optionally the FElupe script (ADR 0007); face sets are stored by planes or by the centers of their faces (ADR 0008).
127
+
128
+ ### Added
129
+
130
+ - Screenshots of the model, the results and a pressure in the user guide and the README, made from the sample *Rubber block with a rigid plate* with `docs/make_screenshots.py` (Playwright); the guide documents face sets, pressures and the new shortcuts (#143).
131
+ - Pressures: `pressure.add` acts on the faces of a face set (`fem.SolidBodyPressure`), positive onto the faces, per deformed area. It is an item of the steps with the point loads, ramped as a factor of its pressure, and drawn as arrows normal to the faces. New golden case `block_pressure` (#105).
132
+ - Face sets: `faceset.add` selects faces of the boundary of a section, on a plane or by the centers of picked faces (Shift+click in the viewport), e.g. for pressures. The script makes a boundary region of the merged mesh of the section with the helper `boundary_faces()` and a field of it, linked to the merged field (only in scripts with face sets). The browser lists them under *Face Sets*, the viewport draws them; a face set on tetrahedrons is an issue, because FElupe 12 has no boundary regions of tetrahedrons. ADR 0008; the surfaces of quadratic cells tell the face of every triangle (`curved`) (#142).
133
+ - Save in the project's format and *Save project as…* (Ctrl+Shift+S): a project is a project file (`.felupe.json`) or a project archive (`.felupe.zip`, with its mesh files); *Save project* keeps the format without asking. A project opened from an archive or a sample is an archive, a new one becomes an archive with its first mesh file. *Save project as…* chooses the name and the format, for an archive the FElupe script (the unpacked folder runs with `python <name>.py`), and lists the mesh files with their sizes and the missing ones (#150).
134
+ - Open project archives: *Open project*, the Open button and a drop on the window accept `.felupe.zip` (and any ZIP file), and open the project with its mesh files in one step; files that the project does not use are listed. A project opened from an archive is saved as an archive. Opening a project replaces the mesh files of the previous one (a project that references a file of the same name no longer uses the old mesh), and with unsaved changes the app asks first (#149).
135
+ - Project archives: the format `<name>.felupe.zip` (a plain ZIP file with the project file, its mesh files and optionally the FElupe script, ADR 0007) and a module that writes it deterministically and reads it, also when a user zipped the folder of a project; with fflate in a chunk of its own (#148).
136
+ - Play the substeps: ▷ beside the slider of the substeps (or Space) plays them in a loop at 1–20 substeps per second; the curve and the control points follow. The next scenes are loaded ahead while playing, and the loaded scenes are kept, so substeps that were shown once are shown at once (#141).
137
+ - Minimum and maximum of the contour: *Min/Max* in the results toolbar marks them with labels of their values, a dot at a node or the outlines of the outer faces of a cell. A click on a label or a marker shows the node or the cell and its section (and whether it is inside); a click elsewhere or Esc hides it. A label takes the face nearest to the camera that is not hidden by the model, or is dimmed; the picture export draws the labels. The scalar bar of the displacement reads *Displacement magnitude*. New in Python: `extremes` in the meta data of `felupe_studio.results.scene()` (#140).
138
+ - Contour settings in a popover beside *Contour*: the color map (Turbo, Viridis, Cool–warm centered at zero for signed values, Grayscale), continuous or 6–20 bands, and the range of the substep, over all substeps of the job or manual, with an extra color for values outside of it. The app draws the scalar bar (with the swatches of the extra color), also in the picture export; the settings are kept in the browser. New in Python: `felupe_studio.results.ranges(job, quantity)` (#139).
139
+ - Context menu of an object in the browser: right click, a ⋯ button (on hover, at the selected object, always on touch screens) or Shift+F10, with *Duplicate*, *Rename*, *Show/Hide* and *Delete* (disabled with the objects that use it). *Duplicate* (Ctrl+D) copies the object with the next free name (`rubber_2`) right after the original as one undo step and selects it; references are not copied into other objects, and the model settings cannot be duplicated. H shows or hides the selected object. The menus of the header, the ribbon and the browser share one list component (#138).
140
+ - More material models of tensortrax (`fem.Hyperelastic`): Yeoh (C10, C20, C30), third-order deformation (C10, C01, C11, C20, C30), Ogden (one to three terms μᵢ, αᵢ as lists), Arruda-Boyce (C1, limit) and extended tube (Gc, delta, Ge, beta), each with an optional bulk modulus. They are definitions of the material registry of the schema with labels, units, bounds and the defaults of the FElupe examples; Ogden needs as many exponents as moduli (`x-same-length`, checked in the form and the validation) and no exponent of zero. The *Materials* tab groups the models in menus (*Neo-Hooke ▾*, *Polynomial ▾*, *Micromechanical ▾*, by `x-group`), so it stays one row. Golden cases `cube_<model>` pull a cube to a stretch of 2 and compare the curve with `fem.ViewMaterialIncompressible` (#136).
141
+ - Scale of an imported mesh: `mesh.import` has a `scale` (default 1) that multiplies the coordinates after reading, before the cell sets, e.g. 1000 for a mesh in m of a model in mm. The import dialog shows the size of the mesh and suggests the scale for a mesh that is very small or very large for the units of the model (smaller than 1 mm or larger than 10 m; without units, smaller than 0.01 or larger than 10000). The viewer, the point sets and the points, the checks of the interfaces and the script use the scaled coordinates (#135).
142
+ - The volumetric part of the u-p-J formulation: the section property *Volumetric part* (`volumetric`, only with u-p-J) chooses the strain energy U(J) of `fem.NearlyIncompressible`, *volume-ratio* K/2 (J − 1)² (default), *stretch* 9K/2 (J^⅓ − 1)² or *log* K/2 ln(J)², with the formulas in the options. The script passes it only if it is not the default; the browser shows it at the section. Tests compare all three with FElupe; a golden case (`bar_volumetric_log`) pulls a bar with a small bulk modulus and *log*. The bulk modulus of a section shows the unit of the model (#134).
143
+ - Settings of the Newton-Raphson method and of the cutback of a job: *Max. iterations* (`maxiter`) next to the tolerance, and with a cutback its *Factor*, *Max. cutbacks* and *Growth* (`cutback: {factor, max_cutbacks, growth}`, the parameters of `fem.CutbackPlugin`), each optional with the default of FElupe. The script passes only the given ones; the job panel shows *Newton iteration 3 of 16*. Optional groups of fields in the forms show their hint. A golden case (`bar_cutback`) needs a cutback by a smaller factor (#133).
144
+ - Units of the model: the new command `model.settings` (at most one, *Model settings* in the *Mesh* tab) says what the numbers mean, the units of lengths (mm, m) and forces (N, kN); stresses follow (MPa, GPa, Pa, kPa). FElupe has no units, nothing is converted. The forms show the units at their labels (from `x-quantity` of the schema), also at the rows of the ramps; the browser at the values, the results at the scalar bar, the tooltips, the control points and the curve, and the CSV of curves and control points in the header (e.g. `u_x [mm]`); the script gets a comment. Rotations are always in rad. The samples *Rubber mount in shear* and *Rubber block with a rigid plate* are in mm and N (#132).
145
+ - Script view: the ribbon tab **Script** shows the FElupe script of the model instead of the viewport, as it is exported and updated after every change, with highlighted Python and line numbers. The lines of the selected object are highlighted, a click on a line selects its object; *Copy* and *Download*. `felupe_studio.codegen.object_lines()` finds the lines of the objects (#130).
146
+ - Keyboard shortcuts: Ctrl+S save, Ctrl+O open, Ctrl+Enter solve, Delete and F2 for the selected object, Esc clears the selection; F, 1–4 and N in the views; ←, →, Home and End step through the substeps; `?` opens the overview. One list (`core/shortcuts.ts`) feeds the handlers, the overview, the menus (with `aria-keyshortcuts`) and the tooltips. Not while typing, except saving and solving (#129).
147
+ - A welcome panel for an empty model: *Import mesh*, *Open project*, the samples as cards with a picture, and links to the user guide and the tutorial. The pictures (`thumbnail.svg`) are made by `make_samples.py` from the models, in the colors and the default view of the viewport; the Samples dialog shows them too (#127).
148
+ - **File** and **Help** menus in the header: File has new, open, samples, save and the exports; Help links the user guide, the command reference and a new issue, lists the keyboard shortcuts and shows *About* (versions of the app, FElupe, Python, Pyodide, NumPy, SciPy, meshio and tensortrax, the load time, the license, the Pyodide benchmark). The menus work with the keyboard (#126).
149
+
150
+ ### Changed
151
+
152
+ - Polish of the properties: hints without the key of the schema in front (the key, e.g. `C10`, is in the tooltip of the label C₁₀); numbers right-aligned with digits of equal width; an issue of the validation is shown at the field that has it (a reference, the formulation, the coordinates, the axes of a load case, the ramped items, the name), the others below the form without the index of the command; *Apply* and *Reset* only after a change, Enter applies and Esc resets (also in *Help ▸ Keyboard shortcuts*); *Curve boundary* of a job is *Curve*, and an empty selection of all reads *all (default)* (#137).
153
+ - Schema version 3 (for `model.settings` and the settings of the cutback); projects of version 1 and 2 are migrated when they are opened: `"cutback": true` becomes `"cutback": {}`.
154
+ - Narrow windows (up to 1000 px): the browser and the properties are drawers over the views instead of squeezing the viewport (a button in the header opens the browser, a selection closes it and opens the properties, Esc closes them); the ribbon is one row that scrolls, and the header keeps one line. The layout below 800 px no longer stacks the panels below the viewport (#131).
155
+
156
+ - The overlays of the viewports have fixed places and never overlap: the panels and messages at the bottom are stacked between the axes and the job panel, the cards of the results form one column on the right, and in a narrow view (also with the properties open) the job panel spans the width at the bottom while the legend and the cards move below the view toolbar. The tips are shorter and quieter (#128).
157
+ - The header keeps icon buttons for Open, Save, Export, Undo and Redo; New and Samples are in the File menu. The ribbon tab *Tools* is gone, its benchmark link is in Help ▸ About (#126).
158
+ - One set of design tokens (colors, type, spacing, radii, shadows, stacking) and consistent components: all inputs and selects share one style (also in the results and the curve), buttons have hover and a clear disabled state, one focus ring for keyboard navigation, overlays on the viewport share one surface; a test keeps the styles on the tokens (#125).
159
+
160
+ ## [0.2.0] - 2026-11-11
161
+
162
+ Multi-point constraints: control points, rigid connections of point sets with rotation points, point loads, and steps that ramp several items with their own values. Projects of schema version 1 (v0.1) are migrated when they are opened; projects saved with v0.2 have schema version 2. With a user guide and a command reference.
163
+
164
+ ### Added
165
+
166
+ - Documentation: a [user guide](docs/guide.md) with a tutorial, and a [command reference](docs/reference.md) generated from the schema (`python docs/make_reference.py`); the schema describes all properties, which the forms show as hints (#33).
167
+ - Sample *Rubber block with a rigid plate*: a multi-point constraint with a rotation point, moved and tilted in one step (#102).
168
+ - Results of control points: displacement and force (rotation and moment of a rotation point) on hover, in a card per substep and as CSV of all substeps (#101).
169
+ - Point loads (`load.add`, `fem.PointLoad`) on point sets and control points, ramped by the steps as a factor of the force; force-controlled curves; arrows in the viewport (#100).
170
+ - Multi-point constraints in the viewport: lines from the center to the connected points, also displaced in the results, and a warning for points that a boundary prescribes as well (#99).
171
+ - Curves of rotation points show the moment over the rotation (*Moment–rotation*); the properties say when values are rotations (#98).
172
+ - Multi-point constraints (`mpc.add`, `fem.MultiPointConstraint`): the points of a point set follow a control point, optionally with a rotation point; items of the steps (#97).
173
+ - **Control point at center** of the selected point set, of a picked face or of picked nodes (#96).
174
+ - Control points in the viewport: drawn as markers (also displaced in the results), selected by a click, listed under **Points** in the browser (#95).
175
+ - Control points (`point.add`): points that are not nodes of the meshes, merged as a mesh of vertices and referenced like a point set, e.g. by a boundary (#94, ADR 0006).
176
+ - Picking nodes: with **Nodes** shown, a click picks a node, Shift+click more; create a point set of them, add them to the selected one or copy their coordinates (#93).
177
+ - Point sets by nodes: the coordinates of points, one per line, stored by coordinates instead of ids of the merged mesh; the viewport warns about coordinates without a node (#92).
178
+ - **Nodes** in the view toolbar shows the nodes of the visible meshes, also in the results (#91).
179
+ - A tolerance of the Newton-Raphson method per job (`tol`), e.g. 0.05 to loosen it (#106).
180
+ - Boundaries and load cases in the viewport: strokes of the fixed components and arrows of the moved boundaries, also of the load cases like `fem.dof` (#82).
181
+ - Results: hovering shows the value under the pointer, of a cell (strains, stresses) or of a node (displacements), with its cell or node (#85).
182
+ - Samples (header and empty model): four finished models with their mesh files, opened like a project file (#32).
183
+ - The properties of the selected object are shown in a panel on the right of the viewport, which opens on selection and can be closed; the browser has the left sidebar for itself (#83).
184
+ - The project and its mesh files are kept in the browser (IndexedDB), so a reload restores them; **New project** in the header starts an empty project and clears them (#57).
185
+
186
+ ### Changed
187
+
188
+ - Schema version 2: a step ramps a list of items, each with its own start and end value and the same increments, e.g. a displacement and a rotation; *Also ramped* is gone. The properties edit them as rows. Projects of schema version 1 are migrated when they are opened, in the app and in `felupe_studio` (#90).
189
+
190
+ ### Fixed
191
+
192
+ - The panel of a running job keeps its size: fixed lines for the position, the Newton iteration and the retries of a cutback, without wrapping (#108).
193
+ - `u-p-J` with tetrahedrons in a model with more than one section (#76).
194
+ - An object created later can be chosen in an existing object, e.g. a new material in a section; the command list is reordered so that every reference points to an object before (#80).
195
+ - Dropdowns no longer offer an option twice: the default axis of a load case is shown as e.g. `x (default)`, and *Also ramped* does not offer the ramped boundary (#88).
196
+
197
+ ## [0.1.0] - 2026-11-10
198
+
199
+ The first release: a model of hyperelastic solids, from mesh files to results, in the browser.
200
+
201
+ ### Model
202
+
203
+ - Import mesh files (VTU, Gmsh and the other formats of meshio) with one or more types of solid cells; cell sets from cell tags or from whole mesh files; merge points of meshes with a tolerance.
204
+ - Materials of the material registry: Neo-Hooke, Neo-Hooke (compressible), Mooney-Rivlin and linear-elastic (large strain).
205
+ - Sections with the displacement formulation (`u`) or the mixed formulation (`u-p-J`, MINI element for linear tetrahedrons) for every supported cell type.
206
+ - Point sets by a plane or by point ids, also by clicking a face in the viewport; boundaries, load cases of `fem.dof` (uniaxial, biaxial, planar, shear) and ramps of several boundaries.
207
+ - Steps and jobs, with a force-displacement curve of a boundary and an optional cutback.
208
+
209
+ ### App
210
+
211
+ - Desktop layout bound to a command list with undo and redo: ribbon, browser, generated properties forms, command line and history.
212
+ - Project files (`.felupe.json`): a text-diffable command list.
213
+ - WebGL2 viewport with the viewer of FElupe: cells colored by mesh, cell set or section, visibility, point sets as markers, view toolbar and axis triad.
214
+ - Solve in a Pyodide worker with live progress (substeps, Newton iterations), cancel and the Python traceback of a failed run.
215
+ - Results: deformed shape with contours of the displacement, the principal logarithmic strains and Cauchy stresses and the von Mises stress per substep; the force-displacement curve with a table and CSV.
216
+ - Exports: the FElupe script of the model, the results as XDMF (all substeps) or VTU (a substep), and a PNG of the view.
217
+ - A service worker caches Pyodide and the wheels, so later visits start faster; a notice reports a newer deployment of the app.
218
+
219
+ ### Python package
220
+
221
+ - `felupe_studio.codegen()`: the command list as a readable FElupe script, checked by golden tests against reference curves.
222
+ - JSON schema of the command list (schema version 1) as the single source of the app and of the package.
223
+
224
+ [0.6.0]: https://github.com/adtzlr/felupe-studio/releases/tag/v0.6.0
225
+ [0.5.0]: https://github.com/adtzlr/felupe-studio/releases/tag/v0.5.0
226
+ [0.4.0]: https://github.com/adtzlr/felupe-studio/releases/tag/v0.4.0
227
+ [0.3.0]: https://github.com/adtzlr/felupe-studio/releases/tag/v0.3.0
228
+ [0.2.0]: https://github.com/adtzlr/felupe-studio/releases/tag/v0.2.0
229
+ [0.1.0]: https://github.com/adtzlr/felupe-studio/releases/tag/v0.1.0