Table des matières

Dimension : Du stockage matriciel à la scène affichée

Dimension est mon espace de travail Rust pour les mathématiques et l’infographie. mathlib fournit les outils numériques; render les utilise pour les transformations et les caméras côté CPU avant de soumettre le travail graphique à wgpu.

Bibliothèque

Mis à jour 2026-10-23
Rust · 63.95%
MIT

Rust Node.js Playwright cargo test

Code source README Markdown

Langages: 10Répartition du code
Composants documentés: 2Explorer les modules
Documents source: 21Lire les instructions

Langages du dépôtRust 63.95%10

Parts calculées à partir des octets GitHub Linguist.

Rust63.95%

63.95%2 691 477 octets

JavaScript31.84%

31.84%1 340 031 octets

HTML2.57%

2.57%108 173 octets

Just0.52%

0.52%21 784 octets

Langage	%	Octets
Rust	63.95%	2 691 477
JavaScript	31.84%	1 340 031
HTML	2.57%	108 173
Just	0.52%	21 784
CSS	0.51%	21 650
WGSL	0.4%	16 946

4 autres langages

TypeScript	0.13%	5 627
Python	0.04%	1 817
Shell	0.02%	751
Dockerfile	0.01%	389

GitHub README Statistiques de langages

1. Aperçu

1.1. Pourquoi il existe

Pipeline graphique wgpu haute performance et moteur d'algèbre linéaire implémentés en Rust à partir des fondamentaux.

1.2. Cas d’usage

Rendu 3D de cartes de relief accéléré matériellement, transformations spatiales et apprentissage de l'infographie.

2. Cas d’utilisation

Un espace de travail Rust autour de mathlib : algèbre linéaire, rendu wgpu, analyseurs, physique et géométrie, avec démos WASM.

Acteurs à gauche (personnes) et à droite (systèmes externes) ; chaque ovale est un cas d’utilisation appuyé par les fichiers cités ci-dessous.

Calculer en dense et creux: Développeur Rust
Le crate mathlib fournit matrices denses et creuses, vecteurs, SVD et outils 3D ; cd mathlib && cargo test et cargo bench les mettent à l’épreuve.
Rendre une scène 3D avec wgpu: Développeur RustGPU via wgpu
Le crate render dessine une scène mathlib Tree avec wgpu ; cargo run -p render-demo --example render_native ouvre une fenêtre avec un cube, un manipulateur et la sélection.
Charger maillages et fichiers: Développeur Rust
Le crate parse lit JSON, XML, OBJ, MTL, BVH, glTF, PLY, PNG, JPEG, ZIP et TAR, chacun derrière une fonctionnalité Cargo comme json ou obj.
Simuler physique et collisions: Développeur Rust
physics implémente PBD/XPBD avec les exemples particles_2d, rigid_bodies_3d et softbody_3d ; collision ajoute les requêtes AABB, OBB, BVH, BSP, rayon et frustum.
Publier le site de démos WASM: Développeur RustNavigateur WASM/WebGPU
just website-build compile en WASM les démos mathlib, render, kinematics, physics, geometry et neural dans website/ ; pages.yml les déploie sur GitHub Pages.

2.1. Scénario : Essayer les démos en local avant de pousser

Lancer cd mathlib && cargo test pour vérifier la bibliothèque de base.
Lancer just run-render pour ouvrir la scène wgpu native et déplacer le manipulateur.
Lancer just website-build pour compiler chaque démo en WASM dans website/.
Lancer just website-serve et ouvrir http://localhost:3000/ pour parcourir /mathlib/, /render/ et /physics/.
Pousser sur main ; le flux Pages reconstruit website/ et le publie.

Fichiers consultésREADME.mdCargo.tomljustfiledocs/website.mdmathlib/README.mdrender/README.mdparse/README.mdphysics/Cargo.tomlcollision/Cargo.toml.github/workflows/pages.yml

3. Démarrage

Ces commandes viennent de la documentation du dépôt. Elles n’ont pas été exécutées pendant cette revue.

kinematics/README.md · Build, test, bench

cd kinematics
cargo build
cargo test
cargo bench
cargo run --example forward_kinematics
cargo run --example jacobian_ik

mathlib/demo/README.md · Build and serve

just wasm-build      # or just wasm-build-gpu for GPU support
just wasm-serve

mathlib/demo/wasm-demo/README.md · Build

wasm-pack build --target web --features wasm

neural/README.md · Downloading ONNX models

cargo run -p neural --bin download_models -- --all

neural/README.md · Precomputing embeddings for the WASM recommendation demo

cargo run -p neural --example precompute_demo_embeddings --features precompute -- mathlib/demo/wasm-demo/recommendation/data.json

render/README.md · Build and run

cargo run -p render-demo --example render_native

render/README.md · Build and run

just render-wasm         # build + serve; open http://localhost:3000/wasm-demo/

website/README.md · Build and serve (local)

just website-build        # Build all WASM demos and populate website/
just website-build-gpu    # Same, but with GPU-enabled mathlib (WebGPU init, async matmul, etc.)
just website-build-simd   # Same as website-build, but render demo built with SIMD (can improve frame rate)
just website-serve        # Serve website/ (e.g. http://localhost:3000)

Commandes déclarées dans les manifestes

3.1. `e2e/package.json`

test: playwright test

4. Références du dépôt

Extraits des guides du dépôt, dans leur langue d’origine. Les liens ouvrent la version du code consultée.

Prérequis et premier essai

4.1. Getting started

CONTRIBUTING.md

All code lives in the mathlib/ crate. From the repo root: Optional: use just from the repo root (see justfile) for common tasks. For a containerized dev environment, see .devcontainer. For pre-commit hooks (fmt, clippy, typos), see .pre-commit-config.yaml and docs/dev-tools.md.

Lire les instructions complètes ↗

Exploitation et dépannage

4.2. Performance / Troubleshooting

render/demo/README.md

Use a modern browser with WebGPU enabled (Chrome, Edge, or Firefox with dom.webgpu.enabled) for best frame rate; software or limited WebGPU can cause slow FPS.
For potentially better FPS on CPU-bound work (math, culling), build the render WASM demo with SIMD: just wasm-render-build-simd, then just wasm-render-serve, and open the same URL.

Lire les instructions complètes ↗

Développement et contributions

4.3. Contributing to Dimension

CONTRIBUTING.md

Thanks for your interest in contributing. This project hosts mathlib, a Rust linear algebra library.

Lire les instructions complètes ↗

4.4. Development workflow

CONTRIBUTING.md

Fork and clone the repository.
Create a branch for your change (e.g. fix/svd-edge-case, feat/sparse-format).
Make your changes in mathlib/. Keep formatting and style consistent with the existing codebase.
Run tests and lints:
Submit a pull request with a clear description of the change and why it’s needed.

Lire les instructions complètes ↗

4.5. E2E tests (Playwright)

e2e/README.md

Browser end-to-end tests for WASM demos. Requires Node.js and Playwright browsers.

Lire les instructions complètes ↗

4.6. What the tests do

e2e/README.md

Render (tests/render.spec.ts): Opens the render WASM demo at /wasm-demo/, checks the canvas is visible with width/height, ensures the error div is not shown, and takes a screenshot for visual regression.
Kinematics (tests/kinematics.spec.ts): Opens the kinematics-demo WASM at /wasm-demo/, checks the canvas (800×600) is visible and the error div is not shown, verifies the hint text (orbit / IK / zoom), and that the page title matches the demo.

Lire les instructions complètes ↗

4.7. E2E tests (Playwright) (README.md)

render/demo/README.md

From repo root:

Lire les instructions complètes ↗

Documentation source

21 documents lus parmi 21 candidats.

5. Fonctions et composants 2

Données et opérations numériques: mathlib expose du stockage dense et creux, des vues matricielles, des vecteurs et des méthodes numériques. L’appelant choisit la représentation adaptée au problème. Les fonctions d’exécution optionnelles sont distinctes de l’API de stockage de base.
Scène et frontière de plateforme: render expose World, EntityId et Transform ainsi que des relations parent-enfant dans la scène. Les fenêtres natives et le canevas WebAssembly entourent le moteur de rendu. L’espace de travail contient aussi des crates de géométrie, collision, cinématique et physique.

6. Architecture

Ouvrez un composant pour suivre ses connexions, ou explorez le diagramme complet.

Composants du système Contexte

Application ou démo
- Vers Données et transformations mathlib
Données et transformations mathlib
- Depuis Application ou démo
- Vers Hiérarchie de scène et caméra
Hiérarchie de scène et caméra
- Depuis Données et transformations mathlib
- Vers Ressources et passes wgpu
Ressources et passes wgpu
- Depuis Hiérarchie de scène et caméra
- Vers Fenêtre native ou canevas web
Fenêtre native ou canevas web
- Depuis Ressources et passes wgpu

Mermaid Diagramme interactif

Vue générale des composants et des échanges vérifiés dans le dépôt.

Vue statique de l’architecture de Dimension — Aperçu statique. Le diagramme interactif le remplace après le chargement de Mermaid.

flowchart LR
node_application(("Application"))
node_api["Public API<br/>[lib.rs]"]

subgraph group_compute["Compute Backends"]
  node_cpu["CPU Dispatch<br/>[mod.rs]"]
  node_parallel["Parallel CPU<br/>[parallel.rs]"]
  node_sequential["Sequential CPU<br/>[sequential.rs]"]
  node_simd["SIMD CPU<br/>[simd.rs]"]
  node_executor["Execution<br/>[executor.rs]"]
  node_gpu["GPU Compute<br/>[mod.rs]"]
  node_pipelines["GPU Pipelines<br/>[pipelines.rs]"]
  node_shaders["GPU Shaders<br/>[shaders.rs]"]
end

subgraph group_algorithms["Numerical Algorithms"]
  node_linear["Linear Solvers<br/>[solve.rs]"]
  node_decomposition["Decomposition<br/>[svd.rs]"]
  node_optimization["Optimization<br/>[linesearch.rs]"]
  node_graph["Graph Algorithms<br/>[mod.rs]"]
end

subgraph group_domains["Math Domains"]
  node_math3d["3D Math<br/>[math3d.rs]"]
  node_transforms["Transforms<br/>[mod.rs]"]
  node_ml["ML and Statistics<br/>[mod.rs]"]
  node_noise["Noise<br/>[mod.rs]"]
end

subgraph group_data["Linear Algebra Data"]
  node_matrix["Matrices<br/>[matrix.rs]"]
  node_vector["Vectors<br/>[vector.rs]"]
  node_storage[("Matrix Storage<br/>[dense_storage.rs]")]
  node_operators["Operators<br/>[operators.rs]"]
end

node_application -->|"uses"| node_api
node_cpu -->|"dispatches"| node_parallel
node_cpu -->|"dispatches"| node_sequential
node_cpu -->|"dispatches"| node_simd
node_pipelines -->|"uses shaders"| node_shaders
node_api --> group_data
node_api -->|"exports"| group_algorithms
node_api --> group_domains
class node_matrix,node_vector,node_storage,node_operators toneBlue
class node_cpu,node_parallel,node_sequential,node_simd,node_executor,node_gpu,node_pipelines,node_shaders toneAmber
class node_linear,node_decomposition,node_optimization,node_graph,node_api toneMint
class node_math3d,node_transforms,node_ml,node_noise toneRose
class node_application toneIndigo

Un espace de travail mathématique en Rust centré sur mathlib. Les applications construisent des vecteurs, matrices et cubes, puis appliquent des opérations numériques, géométriques et analytiques avant de rejoindre les modules de rendu.

Composants: 22
Connexions: 17
Liens appuyés par le code: 16/17

Version texte du diagramme

Le diagramme regroupe les liens parallèles entre groupes : il en montre 8 sur 17. Liste complète :

Application → Public API (uses)
Public API → Matrices (exports)
Public API → Vectors (exports)
Public API → Matrix Storage (exports)
Public API → Operators (exposes)
Public API → Linear Solvers (exports)
Public API → Decomposition (exports)
Public API → Optimization (exports)
Public API → Graph Algorithms (exports)
Public API → 3D Math (exports)
Public API → Transforms (exports)
Public API → ML and Statistics (exports)
Public API → Noise (exposes)
CPU Dispatch → Parallel CPU (dispatches)
CPU Dispatch → Sequential CPU (dispatches)
CPU Dispatch → SIMD CPU (dispatches)
GPU Pipelines → GPU Shaders (uses shaders)

Suivre un parcours dans le code

Pour une mise à jour de scène, partez du Transform local et de son parent. Suivez la scène vers le moteur sans supposer qu’un calcul matriciel s’exécute sur le GPU. wgpu est le moteur graphique; l’exécution GPU optionnelle de mathlib est une fonction différente.

7. Dossier technique

Établi à partir du code au commit 5281d09 (667 fichiers). Chaque élément vient d’une correspondance de motif dans le code: ouvrez le fichier lié avant de vous y fier.

7.1. Couches et modules

Les dossiers sont classés par couche selon leur nom, de l’interface utilisateur jusqu’à l’accès aux données. Comme le classement repose sur les noms seulement, le diagramme ne dit rien des appels entre couches.

Mermaid Vue en couches

flowchart TB
  subgraph L_presentation["Présentation"]
    direction TB
    presentation_0["mathlib/demo<br/>15 fichiers"]
    presentation_1["render/ui<br/>6 fichiers"]
    presentation_2["website<br/>2 fichiers"]
    presentation_3["website/neural<br/>2 fichiers"]
    presentation_more["+3"]
  end
  subgraph L_interface["Points d’entrée et API"]
    direction TB
    interface_0["network/server<br/>5 fichiers"]
    interface_1["neural/bin<br/>1 fichier"]
  end
  subgraph L_application["Services applicatifs"]
    direction TB
    application_0["mathlib/demo<br/>1 fichier"]
    application_1["mathlib/gpu<br/>1 fichier"]
    application_2["neural/scripts<br/>1 fichier"]
    application_3["render/src<br/>1 fichier"]
    application_more["+1"]
  end
  subgraph L_domain["Domaine et règles métier"]
    direction TB
    domain_0["physics/src<br/>19 fichiers"]
    domain_1["mathlib/math<br/>12 fichiers"]
    domain_2["physics/demo<br/>11 fichiers"]
    domain_3["geometry/src<br/>10 fichiers"]
    domain_more["+11"]
  end
  subgraph L_infrastructure["Données et infrastructure"]
    direction TB
    infrastructure_0["network/utils<br/>11 fichiers"]
    infrastructure_1["network/transport<br/>4 fichiers"]
    infrastructure_2["network/examples<br/>3 fichiers"]
    infrastructure_3["network/protocol<br/>3 fichiers"]
    infrastructure_more["+8"]
  end
  subgraph L_core["Source principale"]
    direction TB
    core_0["mathlib/benches<br/>48 fichiers"]
    core_1["mathlib/examples<br/>37 fichiers"]
    core_2["mathlib/demo<br/>23 fichiers"]
    core_3["mathlib/wasm<br/>18 fichiers"]
    core_more["+46"]
  end
  subgraph L_tests["Tests"]
    direction TB
    tests_0["mathlib<br/>95 fichiers"]
    tests_1["parse<br/>15 fichiers"]
    tests_2["geometry<br/>6 fichiers"]
    tests_3["render<br/>6 fichiers"]
    tests_more["+6"]
  end
  subgraph L_hosting["Build, CI et hébergement"]
    direction TB
    hosting_0[".github<br/>11 fichiers"]
    hosting_1[".devcontainer<br/>2 fichiers"]
    hosting_2["(root)<br/>1 fichier"]
    hosting_3["website<br/>1 fichier"]
  end
  L_presentation ~~~ L_interface
  L_interface ~~~ L_application
  L_application ~~~ L_domain
  L_domain ~~~ L_infrastructure
  L_infrastructure ~~~ L_core
  L_core ~~~ L_tests
  L_core ~~~ L_hosting

Modules et couche principale
Module	Couche	Fichiers	Types	Extensions
`mathlib/benches`	Source principale	48	0	.rs
`mathlib/demo`	Source principale	39	51	.js .html .ts
`mathlib/examples`	Source principale	38	1	.rs
`physics/src`	Domaine et règles métier	19	22	.rs
`website/mathlib`	Source principale	19	0	.js .css
`mathlib/wasm`	Source principale	18	30	.rs
`mathlib/src`	Source principale	17	23	.rs
`parse/src`	Source principale	16	27	.rs
`kinematics/demo`	Source principale	15	7	.rs .ts .js
`mathlib/graph`	Source principale	14	12	.rs
`render/demo`	Source principale	14	1	.rs .ts .html
`collision/src`	Source principale	13	14	.rs
`mathlib/math`	Domaine et règles métier	12	10	.rs
`network/utils`	Données et infrastructure	11	13	.rs

62 modules plus petits ne sont pas affichés.

7.2. Modèle C4

Du contexte du système aux déclarations du code. Chaque niveau conserve les limites des sources disponibles.

UML 1 · Contexte du système

La vue C4 la plus large : qui utilise le projet et sur quels systèmes et stockages externes il s’appuie. Rendu avec uml-mcp.

Source PlantUML

@startuml
!include <C4/C4_Context>
LAYOUT_LEFT_RIGHT()
Person(P_http, "Client HTTP")
Person(P_cli, "Utilisateur CLI")
System(SYS, "Dimension", "Dimension est mon espace de travail Rust pour les mathématiques et l’…")
System_Ext(E0, "Hugging Face")
Rel(P_http, SYS, "Utilise")
Rel(P_cli, SYS, "Utilise")
Rel(SYS, E0, "Appelle")
@enduml

UML 2 · Conteneurs

Un niveau plus près : les parties qui s’exécutent séparément dans le projet, leur langage principal et le chemin des appels entre elles. Rendu avec uml-mcp.

Source PlantUML

@startuml
!include <C4/C4_Container>
LAYOUT_LEFT_RIGHT()
Person(P_http, "Client HTTP")
Person(P_cli, "Utilisateur CLI")
System_Boundary(SYS, "Dimension") {
  Container(APP, "Dimension", "Rust")
}
System_Ext(E0, "Hugging Face")
Rel(P_http, APP, "Utilise")
Rel(P_cli, APP, "Utilise")
Rel(APP, E0, "Appelle")
@enduml

UML 3 · Composants et couches

Modules regroupés par couche du code. Les limites indiquent l’organisation, sans affirmer une isolation à l’exécution ni des appels. Rendu avec uml-mcp.

Source PlantUML

@startuml
!include <C4/C4_Component>
LAYOUT_TOP_DOWN()
System_Boundary(SYS, "Dimension") {
Boundary(L0, "Présentation", "layer") {
Component(M0_0, "mathlib/demo", "HTML, .css", "15 fichiers")
Component(M0_1, "render/ui", "Rust", "6 fichiers")
Component(M0_2, "website", "HTML", "2 fichiers")
Component(M0_3, "website/neural", "HTML", "2 fichiers")
Component(M0_4, "kinematics/demo", "HTML", "1 fichiers")
Component(M0_5, "render/demo", "HTML", "1 fichiers")
Component(M0_6, "website/mathlib", ".css", "1 fichiers")
}
Boundary(L1, "Points d’entrée et API", "layer") {
Component(M1_0, "network/server", "Rust", "5 fichiers")
Component(M1_1, "neural/bin", "Rust", "1 fichiers")
}
Boundary(L2, "Services applicatifs", "layer") {
Component(M2_0, "mathlib/demo", "JavaScript", "1 fichiers")
Component(M2_1, "mathlib/gpu", "Rust", "1 fichiers")
Component(M2_2, "neural/scripts", "Python", "1 fichiers")
Component(M2_3, "render/src", "Rust", "1 fichiers")
Component(M2_4, "website/mathlib", "JavaScript", "1 fichiers")
}
Boundary(L3, "Domaine et règles métier", "layer") {
Component(M3_0, "physics/src", "Rust", "19 fichiers")
Component(M3_1, "mathlib/math", "Rust", "12 fichiers")
Component(M3_2, "physics/demo", "Rust, TypeScript, HTML", "11 fichiers")
Component(M3_3, "geometry/src", "Rust", "10 fichiers")
Component(M3_4, "geometry/demo", "Rust, TypeScript, JavaScript", "9 fichiers")
Component(M3_5, "geometry/examples", "Rust", "3 fichiers")
Component(M3_6, "physics/examples", "Rust", "3 fichiers")
Component(M3_7, "website/geometry", "TypeScript, JavaScript", "3 fichiers")
Component(M3_more, "+7 modules", "", "")
}
Boundary(L4, "Données et infrastructure", "layer") {
Component(M4_0, "network/utils", "Rust", "11 fichiers")
Component(M4_1, "network/transport", "Rust", "4 fichiers")
Component(M4_2, "network/examples", "Rust", "3 fichiers")
Component(M4_3, "network/protocol", "Rust", "3 fichiers")
Component(M4_4, "network/serialize", "Rust", "3 fichiers")
Component(M4_5, "render/platform", "Rust", "3 fichiers")
Component(M4_6, "network/src", "Rust", "2 fichiers")
Component(M4_7, "mathlib/clustering", "Rust", "1 fichiers")
Component(M4_more, "+4 modules", "", "")
}
Boundary(L5, "Source principale", "layer") {
Component(M5_0, "mathlib/benches", "Rust", "48 fichiers")
Component(M5_1, "mathlib/examples", "Rust", "37 fichiers")
Component(M5_2, "mathlib/demo", "JavaScript, TypeScript", "23 fichiers")
Component(M5_3, "mathlib/wasm", "Rust", "18 fichiers")
Component(M5_4, "mathlib/src", "Rust", "17 fichiers")
Component(M5_5, "website/mathlib", "JavaScript", "17 fichiers")
Component(M5_6, "parse/src", "Rust", "16 fichiers")
Component(M5_7, "kinematics/demo", "Rust, TypeScript, JavaScript", "14 fichiers")
Component(M5_more, "+42 modules", "", "")
}
Boundary(L6, "Tests", "layer") {
Component(M6_0, "mathlib", "Rust", "95 fichiers")
Component(M6_1, "parse", "Rust, .xml", "15 fichiers")
Component(M6_2, "geometry", "Rust", "6 fichiers")
Component(M6_3, "render", "Rust", "6 fichiers")
Component(M6_4, "physics", "Rust", "5 fichiers")
Component(M6_5, "e2e", "TypeScript", "4 fichiers")
Component(M6_6, "network", "Rust", "4 fichiers")
Component(M6_7, "kinematics", "Rust", "3 fichiers")
Component(M6_more, "+2 modules", "", "")
}
Boundary(L7, "Build, CI et hébergement", "layer") {
Component(M7_0, ".github", ".yml, .md, .sh", "11 fichiers")
Component(M7_1, ".devcontainer", ".json, .sh", "2 fichiers")
Component(M7_2, "(root)", "justfile", "1 fichiers")
Component(M7_3, "website", "Dockerfile", "1 fichiers")
}
}
@enduml

UML 4 · Code

Déclarations, champs et méthodes sélectionnés, regroupés par fichier source. Aucun héritage ni appel n’est déduit. Rendu avec uml-mcp.

Source PlantUML

@startuml
skinparam backgroundColor transparent
skinparam shadowing false
skinparam roundCorner 10
skinparam defaultFontName Arial
skinparam defaultFontSize 13
skinparam ArrowColor #4e6070
skinparam ArrowFontColor #3d4f5f
skinparam titleFontSize 14
skinparam actorBorderColor #006a62
skinparam actorBackgroundColor #e9f3f4
skinparam usecaseBorderColor #006a62
skinparam usecaseBackgroundColor #e9f3f4
skinparam componentBorderColor #006a62
skinparam componentBackgroundColor #e9f3f4
skinparam interfaceBorderColor #006a62
skinparam interfaceBackgroundColor #ffffff
skinparam nodeBorderColor #4e6070
skinparam nodeBackgroundColor #f4f8fb
skinparam databaseBorderColor #006a62
skinparam databaseBackgroundColor #ffffff
skinparam cloudBorderColor #4e6070
skinparam cloudBackgroundColor #f0f5fa
skinparam artifactBorderColor #006a62
skinparam artifactBackgroundColor #ffffff
skinparam rectangleBorderColor #b0c2d3
skinparam activityBorderColor #006a62
skinparam activityBackgroundColor #e9f3f4
skinparam partitionBorderColor #b0c2d3
skinparam stereotypeCBackgroundColor #ffffff
top to bottom direction
hide empty members
package "Dimension" {
package "render/src/scene/world.rs" as F0 {
class "World" as T0_0 {
  spawn()
  get()
  get_mut()
  set_transform()
  set_primitive()
  set_color()
}
}
package "mathlib/src/graph/types.rs" as F1 {
class "Graph" as T1_0 {
  from_adjacency_list()
  from_grid_2d()
  from_grid_2d_with_weights()
  from_grid_2d_edge_weights()
  add_edge()
  add_undirected_edge()
}
}
package "mathlib/src/wasm/matrix.rs" as F2 {
class "WasmMatrix32" as T2_0 {
  from_inner()
  clone_inner()
  identity4()
  rotation()
  from_array()
  rows()
}
class "WasmMatrix" as T2_1 {
  from_array()
  identity()
  rows()
  cols()
  get()
  set()
}
}
package "mathlib/src/wasm/graph.rs" as F3 {
class "WasmGraph" as T3_0 {
  from_edges()
  from_grid_2d()
  from_grid_2d_edge_weights()
  add_edge()
  add_edge_undirected()
  run_dijkstra()
}
}
package "physics/src/state.rs" as F4 {
class "PhysicsState" as T4_0 {
  with_particles()
  num_particles()
  num_rigid_bodies()
  num_soft_bodies()
  add_rigid_body()
  add_soft_body()
}
class "PhysicsConfig" as T4_1 {
  dt
  substeps
  solver_iterations
  stabilization_iterations
  sor_omega
  sleep_threshold
  gravity
  contact_friction
}
}
package "mathlib/src/math/quaternion.rs" as F5 {
class "Quat4f" as T5_0 {
  identity()
  from_euler_angles()
  from_rotation_matrix3()
  to_euler_angles()
  from_axis_angle()
  to_scaled_axis()
}
}
package "physics/src/particle.rs" as F6 {
class "Particle" as T6_0 {
  kinematic()
  with_phase()
  with_radius()
  is_kinematic()
  default()
}
}
package "physics/src/softbody.rs" as F7 {
class "SoftBody" as T7_0 {
  from_youngs()
  with_phase()
  compliance_deviatoric()
  compliance_hydrostatic()
  global_index()
}
}
package "mathlib/src/executor.rs" as F8 {
class "AutoExecutor" as T8_0 {
  default()
  with_thresholds()
  use_gpu_matmul()
  use_gpu_dot()
  use_gpu_matvec()
  use_gpu_elementwise()
}
}
package "mathlib/src/math/dual_quaternion.rs" as F9 {
class "DualQuat4f" as T9_0 {
  real_w
  real_x
  real_y
  real_z
  dual_w
  dual_x
  dual_y
  dual_z
}
}
package "physics/src/body.rs" as F10 {
class "RigidBody" as T10_0 {
  x
  v
  inv_mass
  q
  omega
  inv_inertia
  shape
  phase
}
}
package "physics/src/body_constraint.rs" as F11 {
class "RigidContactConstraint" as T11_0 {
  body_a
  body_b
  r_a
  r_b
  normal
  tangent1
  tangent2
  depth
}
class "PositionalConstraint" as T11_1 {
  body_a
  body_b
  r_a
  r_b
  compliance
  lambda_accum
}
}
package "render/src/backend/camera.rs" as F12 {
class "Camera" as T12_0 {
  width
  height
  projection
  near
  far
  orbit_yaw
  orbit_pitch
  orbit_distance
}
}
package "render/src/engine.rs" as F13 {
class "GizmoDragState" as T13_0 {
  entity_id
  axis
  mode
  start_screen
  start_world_pos
  start_plane_hit
  axis_direction
  start_rotation
}
}
package "parse/src/lib.rs" as F14 {
class "Material" as T14_0 {
  name
  ka
  kd
  ks
  ke
  ns
  ni
  illum
}
}
package "render/src/backend/gpu.rs" as F15 {
class "SlicePlaneUniforms" as T15_0 {
  view_matrix
  proj_matrix
  object_matrix
  length_scale
  transparency
  _pad
  color
  _pad2
}
}
package "render/src/ui/theme.rs" as F16 {
class "Theme" as T16_0 {
  panel_bg
  panel_border
  title_bar
  button_bg
  button_hover
  button_pressed
  slider_track
  slider_thumb
}
}
package "render/src/backend/framebuffer.rs" as F17 {
class "Framebuffer" as T17_0 {
  texture
  view
  depth_texture
  depth_view
  width
  height
  format
}
}
package "render/src/ui/components.rs" as F18 {
class "Slider" as T18_0 {
  id
  rect
  value
  target_value
  velocity
  state
  dragging
}
}
package "mathlib/src/structure/sparse_formats.rs" as F19 {
class "SparseMatrixBCRS" as T19_0 {
  block_vals
  block_col_indices
  row_pointers
  rows
  cols
  block_rows
  block_cols
}
}
package "mathlib/src/decomposition/tsne.rs" as F20 {
class "TsneOptions" as T20_0 {
  n_components
  perplexity
  max_iters
  seed
  init_pca
  early_exaggeration
  momentum
}
}
}
@enduml

7.3. Flux de données

Les appels du diagramme GitDiagram, dans l’ordre où on les rencontre depuis les points d’entrée. GitDiagram produit ce graphe par IA; les chemins de fichiers cités ont été comparés à l’arbre du dépôt.

Mermaid Diagramme de séquence

sequenceDiagram
  autonumber
  participant P0 as CPU Dispatch
  participant P1 as Parallel CPU
  participant P2 as Sequential CPU
  participant P3 as SIMD CPU
  participant P4 as GPU Pipelines
  participant P5 as GPU Shaders
  participant P6 as Application
  participant P7 as Public API
  participant P8 as Matrices
  participant P9 as Vectors
  participant P10 as Matrix Storage
  participant P11 as Operators
  participant P12 as Linear Solvers
  participant P13 as Decomposition
  participant P14 as Optimization
  participant P15 as Graph Algorithms
  participant P16 as 3D Math
  participant P17 as Transforms
  participant P18 as ML and Statistics
  P0->>P1: dispatches
  P0->>P2: dispatches
  P0->>P3: dispatches
  P4->>P5: uses shaders
  P6->>P7: uses
  P7->>P8: exports
  P7->>P9: exports
  P7->>P10: exports
  P7->>P11: exposes
  P7->>P12: exports
  P7->>P13: exports
  P7->>P14: exports
  P7->>P15: exports
  P7->>P16: exports
  P7->>P17: exports
  P7->>P18: exports

Étapes en texte

CPU Dispatch vers Parallel CPU dispatches
CPU Dispatch vers Sequential CPU dispatches
CPU Dispatch vers SIMD CPU dispatches
GPU Pipelines vers GPU Shaders uses shaders
Application vers Public API uses
Public API vers Matrices exports
Public API vers Vectors exports
Public API vers Matrix Storage exports
Public API vers Operators exposes
Public API vers Linear Solvers exports
Public API vers Decomposition exports
Public API vers Optimization exports
Public API vers Graph Algorithms exports
Public API vers 3D Math exports
Public API vers Transforms exports
Public API vers ML and Statistics exports
Public API vers Noise exposes

7.4. Interface publique

Du code extérieur peut utiliser tout ce qui est listé ici. Le projet déclare aussi 429 types publics.

UML Cas d’utilisation

Chaque acteur est un type d’appelant, relié à ce qu’il peut demander au projet. Rendu avec uml-mcp.

Source PlantUML

@startuml
skinparam backgroundColor transparent
skinparam shadowing false
skinparam roundCorner 10
skinparam defaultFontName Arial
skinparam defaultFontSize 13
skinparam ArrowColor #4e6070
skinparam ArrowFontColor #3d4f5f
skinparam titleFontSize 14
skinparam actorBorderColor #006a62
skinparam actorBackgroundColor #e9f3f4
skinparam usecaseBorderColor #006a62
skinparam usecaseBackgroundColor #e9f3f4
skinparam componentBorderColor #006a62
skinparam componentBackgroundColor #e9f3f4
skinparam interfaceBorderColor #006a62
skinparam interfaceBackgroundColor #ffffff
skinparam nodeBorderColor #4e6070
skinparam nodeBackgroundColor #f4f8fb
skinparam databaseBorderColor #006a62
skinparam databaseBackgroundColor #ffffff
skinparam cloudBorderColor #4e6070
skinparam cloudBackgroundColor #f0f5fa
skinparam artifactBorderColor #006a62
skinparam artifactBackgroundColor #ffffff
skinparam rectangleBorderColor #b0c2d3
skinparam activityBorderColor #006a62
skinparam activityBackgroundColor #e9f3f4
skinparam partitionBorderColor #b0c2d3
skinparam stereotypeCBackgroundColor #ffffff
left to right direction
actor "Client HTTP" as A_http
actor "Utilisateur CLI" as A_cli
rectangle "Dimension" {
  usecase "GET/POST /rooms (3 routes)" as U0
  usecase "GET /health" as U1
  usecase "Lancer l'outil (2 options)" as U2
}
A_http --> U0
A_http --> U1
A_cli --> U2
@enduml

Routes HTTP 4

Mermaid Carte des routes par préfixe

flowchart LR
  api(["HTTP API"])
  g0["/rooms"]
  api --> g0
  g0r0["GET /rooms"]
  g0 --> g0r0
  g0r1["POST /rooms"]
  g0 --> g0r1
  g0r2["POST /rooms/'room_id'/join"]
  g0 --> g0r2
  g1["/health"]
  api --> g1
  g1r0["GET /health"]
  g1 --> g1r0

Méthode	Chemin	Source
GET	`/health` exploitation	`network/src/transport/http.rs:22`
GET	`/rooms`	`network/src/transport/http.rs:23`
POST	`/rooms`	`network/src/transport/http.rs:24`
POST	`/rooms/{room_id}/join`	`network/src/transport/http.rs:25`

Les routes marquées exploitation exposent la santé, l’état ou l’administration; restreignez-les en production.

Ligne de commande 2

Points d’entrée

main export du paquet mathlib.js mathlib/demo/wasm-demo/pkg/pkg/package.json
types export du paquet mathlib.d.ts mathlib/demo/wasm-demo/pkg/pkg/package.json

7.5. Interface privée

Ces noms sont internes selon les conventions du langage: tiret bas initial, private, static ou pub(crate).

Fonction privée au module: 1358
Fonction visible dans la crate: 20

items_100 collision/benches/collision.rs:10
items_1000 collision/benches/collision.rs:21
bench_ray_aabb collision/benches/collision.rs:32
quat_from_vec_to_vec kinematics/src/ik/util.rs:16
project_onto_plane kinematics/src/ik/util.rs:57
to_wgpu mathlib/src/gpu/config.rs:19

7.6. Services

Service 3

Enginenew_sdl3, new_wasm, enable_ui et 56 autres
GpuRendererdevice, queue, last_gpu_time_ms et 9 autres
TickSchedulerschedule, schedule_after, poll et 1 autres

7.7. Entités et modèle de données 247

Mermaid Diagramme de classes des entités

classDiagram
  direction LR
  class E0["DualQuat4f"] {
    +f32 real_w
    +f32 real_x
    +f32 real_y
    +f32 real_z
    +f32 dual_w
    +f32 dual_x
  }
  class E1["PhysicsConfig"] {
    +f32 dt
    +u32 substeps
    +u32 solver_iterations
    +u32 stabilization_iterations
    +f32 sor_omega
    +f32 sleep_threshold
  }
  class E2["RigidBody"] {
    +x
    +v
    +f32 inv_mass
    +q
    +omega
    +inv_inertia
  }
  class E3["RigidContactConstraint"] {
    +usize body_a
    +usize body_b
    +r_a
    +r_b
    +normal
    +tangent1
  }
  class E4["Camera"] {
    +f32 width
    +f32 height
    +Projection projection
    +f32 near
    +f32 far
    +f32 orbit_yaw
  }
  class E5["GizmoDragState"] {
    +EntityId entity_id
    +GizmoAxis axis
    +GizmoMode mode
    +start_screen
    +start_world_pos
    +start_plane_hit
  }
  class E6["Material"] {
    +String name
    +ka
    +kd
    +ks
    +ke
    +f32 ns
  }
  class E7["SlicePlaneUniforms"] {
    +view_matrix
    +proj_matrix
    +object_matrix
    +f32 length_scale
    +f32 transparency
    +_pad
  }
  class E8["Theme"] {
    +Color panel_bg
    +Color panel_border
    +Color title_bar
    +Color button_bg
    +Color button_hover
    +Color button_pressed
  }
  class E9["Framebuffer"] {
    +Texture texture
    +TextureView view
    +Texture depth_texture
    +TextureView depth_view
    +u32 width
    +u32 height
  }

Une flèche relie un champ à l’entité que son type nomme.

Entité	Nature	Premiers champs
`DualQuat4f`	Enregistrement ou interface	`real_w, real_x, real_y, real_z, dual_w, dual_x, dual_y, dual_z`
`PhysicsConfig`	Enregistrement ou interface	`dt, substeps, solver_iterations, stabilization_iterations, sor_omega, sleep_threshold, gravity, contact_friction`
`RigidBody`	Enregistrement ou interface	`x, v, inv_mass, q, omega, inv_inertia, shape, phase`
`RigidContactConstraint`	Enregistrement ou interface	`body_a, body_b, r_a, r_b, normal, tangent1, tangent2, depth`
`Camera`	Enregistrement ou interface	`width, height, projection, near, far, orbit_yaw, orbit_pitch, orbit_distance`
`GizmoDragState`	Enregistrement ou interface	`entity_id, axis, mode, start_screen, start_world_pos, start_plane_hit, axis_direction, start_rotation`
`Material`	Enregistrement ou interface	`name, ka, kd, ks, ke, ns, ni, illum`
`SlicePlaneUniforms`	Enregistrement ou interface	`view_matrix, proj_matrix, object_matrix, length_scale, transparency, _pad, color, _pad2`

Afficher 6 entités de plus

`Theme`	Enregistrement ou interface	`panel_bg, panel_border, title_bar, button_bg, button_hover, button_pressed, slider_track, slider_thumb`
`Framebuffer`	Enregistrement ou interface	`texture, view, depth_texture, depth_view, width, height, format`
`Slider`	Enregistrement ou interface	`id, rect, value, target_value, velocity, state, dragging`
`SparseMatrixBCRS`	Enregistrement ou interface	`block_vals, block_col_indices, row_pointers, rows, cols, block_rows, block_cols`
`TsneOptions`	Enregistrement ou interface	`n_components, perplexity, max_iters, seed, init_pca, early_exaggeration, momentum`
`PositionalConstraint`	Enregistrement ou interface	`body_a, body_b, r_a, r_b, compliance, lambda_accum`

7.8. Logique métier

Une fois écartés le code d’interface et les services et entités ci-dessus, ces classes ont le plus de méthodes.

World Source principale, 19 méthodes: spawn, get, get_mut, set_transform, set_primitive, set_color
Graph Domaine et règles métier, 19 méthodes: from_adjacency_list, from_grid_2d, from_grid_2d_with_weights, from_grid_2d_edge_weights, add_edge, add_undirected_edge
WasmMatrix32 Source principale, 20 méthodes: from_inner, clone_inner, identity4, rotation, from_array, rows
WasmGraph Source principale, 18 méthodes: from_edges, from_grid_2d, from_grid_2d_edge_weights, add_edge, add_edge_undirected, run_dijkstra
PhysicsState Domaine et règles métier, 7 méthodes: with_particles, num_particles, num_rigid_bodies, num_soft_bodies, add_rigid_body, add_soft_body
WasmMatrix Source principale, 17 méthodes: from_array, identity, rows, cols, get, set
Quat4f Domaine et règles métier, 12 méthodes: identity, from_euler_angles, from_rotation_matrix3, to_euler_angles, from_axis_angle, to_scaled_axis
Particle Domaine et règles métier, 5 méthodes: kinematic, with_phase, with_radius, is_kinematic, default
SoftBody Domaine et règles métier, 5 méthodes: from_youngs, with_phase, compliance_deviatoric, compliance_hydrostatic, global_index
AutoExecutor Source principale, 14 méthodes: default, with_thresholds, use_gpu_matmul, use_gpu_dot, use_gpu_matvec, use_gpu_elementwise

7.9. Base de données et persistance

localStorage du navigateur 2 fichiers

7.10. Intégrations externes

Clients HTTP

fetch reqwest

Hôtes nommés dans le code

huggingface.co 1 fichiers neural/bin/download_models.rs:51

7.11. Stack et dépendances

Rust collision/Cargo.toml 3 à l’exécution, 1 dev

Rust edition 2021

Ouvrir le manifeste

Node.js e2e/package.json 1 dev

Ouvrir le manifeste

Rust geometry/Cargo.toml 7 à l’exécution, 1 dev

Rust edition 2021

Ouvrir le manifeste

Rust kinematics/Cargo.toml 3 à l’exécution

Rust edition 2024

Ouvrir le manifeste

Rust mathlib/Cargo.toml 12 à l’exécution, 4 dev

Rust edition 2024

Ouvrir le manifeste

Rust network/Cargo.toml 18 à l’exécution, 5 dev

Rust edition 2021

Ouvrir le manifeste

Rust neural/Cargo.toml 5 à l’exécution

Rust edition 2021

Ouvrir le manifeste

Rust parse/Cargo.toml 13 à l’exécution, 1 dev

Rust edition 2021

Ouvrir le manifeste

Rust physics/Cargo.toml 8 à l’exécution, 2 dev

Rust edition 2024

Ouvrir le manifeste

Rust render/Cargo.toml 10 à l’exécution, 2 dev

Rust edition 2021

Ouvrir le manifeste

Dépendances externes

50 paquets déclarés (41 à l’exécution, 9 pour le développement) dans collision/Cargo.toml, e2e/package.json, geometry/Cargo.toml, kinematics/Cargo.toml, mathlib/Cargo.toml, network/Cargo.toml, neural/Cargo.toml, parse/Cargo.toml, physics/Cargo.toml, render/Cargo.toml.

Tableau des paquets 50

Dépendances externes
Paquet	Version	Usage	Rôle	Registre
`mathlib`	—	exécution	A math library for Rust	crates.io
`wide`	`0.7`	exécution	A crate to help you go wide.	crates.io
`par-core`	`2.0`	exécution	Switchable parallel execution core	crates.io
`criterion`	`0.5`	développement	Statistics-driven micro-benchmarking library	crates.io
`@playwright/test`	`^1.49.0`	développement	Tests	npmjs.com
`collision`	—	exécution	A collision extension to cgmath	crates.io
`par-iter`	`2.0`	exécution	Fork of rayon, with chili support	crates.io
`wasm-bindgen`	`0.2`	exécution	Easy support for interacting between JS and Rust.	crates.io
`wgpu`	`28`	exécution	Cross-platform, safe, pure-rust graphics API	crates.io
`parse`	—	exécution	Basic parsing from str/bytes. Conversion back to bytes.	crates.io
`tracing`	`0.1`	exécution	Application-level tracing for Rust.	crates.io
`serde`	`1`	exécution	Sérialisation	crates.io
`wasm-bindgen-shared`	`0.2`	exécution	Shared support between wasm-bindgen and wasm-bindgen cli, an internal dependency.	crates.io
`js-sys`	`0.3`	exécution	Bindings for all JS global objects and functions in all JS environments like Node.js and browsers, built on #[wasm_bindgen] using the `was	crates.io
`rand`	`0.10`	exécution	Random number generators and other randomness functionality.	crates.io
`wasm-bindgen-futures`	`0.4`	exécution	Bridging the gap between Rust Futures and JavaScript Promises	crates.io
`futures`	`0.3`	exécution	An implementation of futures and streams featuring zero allocations, composability, and iterator-like interfaces.	crates.io
`image`	`0.25`	développement	Imaging library. Provides basic image processing and encoders/decoders for common image formats.	crates.io
`serde_json`	`1`	développement	Sérialisation	crates.io
`tracing-subscriber`	`0.3`	développement	Utilities for implementing and composing tracing subscribers.	crates.io
`render`	—	exécution	A safe and simple template engine with the ergonomics of JSX	crates.io
`kinematics`	—	exécution	—	crates.io
`prost`	`0.14`	exécution	A Protocol Buffers implementation for the Rust Language.	crates.io
`prost-types`	`0.14`	exécution	Prost definitions of Protocol Buffers well known types.	crates.io
`tonic`	`0.14`	exécution	A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility.	crates.io
`tonic-prost`	`0.14`	exécution	Prost codec implementation for tonic	crates.io
`axum`	`0.8`	exécution	Cadriciel web	crates.io
`futures-util`	`0.3`	exécution	Common utilities and extension traits for the futures-rs library.	crates.io
`tokio`	`1`	exécution	An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications.	crates.io
`tokio-tungstenite`	`0.28`	exécution	Tokio binding for Tungstenite, the Lightweight stream-based WebSocket implementation	crates.io
`tower`	`0.5`	exécution	Tower is a library of modular and reusable components for building robust clients and servers.	crates.io
`tower-http`	`0.6`	exécution	Tower middleware and utilities for HTTP clients and servers	crates.io
`tokio-test`	`0.4`	développement	Tests	crates.io
`tokio-stream`	`0.1`	développement	Utilities to work with Stream and tokio.	crates.io
`ort`	`2.0.0-rc.11`	exécution	A safe Rust wrapper for ONNX Runtime 1.31 - Optimize and accelerate machine learning inference & training	crates.io
`fastembed`	`5`	exécution	Library for generating vector embeddings, reranking locally.	crates.io
`pdf-extract`	`0.10`	exécution	A library to extract content from pdfs	crates.io
`quick-xml`	`0.36`	exécution	High performance xml reader and writer	crates.io
`gltf`	`1`	exécution	glTF 2.0 loader	crates.io
`ply-rs`	`0.1`	exécution	Library for reading/writing ascii and binary PLY files.	crates.io
`minipng`	`0.1`	exécution	Tiny PNG decoder with no dependencies	crates.io
`jpeg-decoder`	`0.3`	exécution	JPEG decoder	crates.io
`zip`	`2`	exécution	Library to support the reading and writing of zip files.	crates.io
`tar`	`0.4`	exécution	A Rust implementation of a TAR file reader and writer. This library does not currently handle compression, but it is abstract over all I/O r	crates.io
`bincode`	`1`	exécution	A binary serialization / deserialization strategy for transforming structs into bytes and vice versa!	crates.io
`wgpu_text`	`28`	exécution	A simple 2D text renderer for wgpu.	crates.io
`ab_glyph`	`0.2`	exécution	API for loading, scaling, positioning and rasterizing OpenType font glyphs.	crates.io
`bytemuck`	`1`	exécution	A crate for mucking around with piles of bytes.	crates.io
`naga`	`28`	développement	Shader translator and validator. Part of the wgpu project	crates.io
`wasm-bindgen-cli`	`0.2`	développement	Command line interface of the #[wasm_bindgen] attribute and project. For more information see https://github.com/wasm-bindgen/wasm-bindgen	crates.io

7.12. Pipeline CI/CD

2 workflows GitHub Actions, 10 tâches. Chaque boîte est une tâche ; les boîtes à double bord publient ou déploient, et les flèches suivent les dépendances needs.

Mermaid Déroulement du pipeline

flowchart LR
  subgraph wf0["CI"]
    direction LR
    wf0_ci["ci<br/>ubuntu-latest"]
    wf0_test_parse["test-parse<br/>ubuntu-latest"]
    wf0_test_features["test-features<br/>ubuntu-latest"]
    wf0_test_gpu["test-gpu<br/>ubuntu-latest"]
    wf0_typos["typos<br/>ubuntu-latest"]
    wf0_security["security<br/>ubuntu-latest"]
    wf0_coverage[["coverage<br/>ubuntu-latest"]]
    wf0_wasm["wasm<br/>ubuntu-latest"]
  end
  subgraph wf1["GitHub Pages"]
    direction LR
    wf1_build_and_deploy[["build-and-deploy<br/>ubuntu-latest"]]
  end
  t0(["push · demande de fusion"])
  t1(["push"])
  d0[("GitHub Pages")]
  t0 --> wf0_ci
  t0 --> wf0_test_parse
  t0 --> wf0_test_features
  t0 --> wf0_test_gpu
  t0 --> wf0_typos
  t0 --> wf0_security
  t0 --> wf0_coverage
  t0 --> wf0_wasm
  t1 --> wf1_build_and_deploy
  wf1_build_and_deploy -.-> d0

Workflows, déclencheurs, tâches et cibles
Workflow	Déclencheurs	Tâches	Publie vers
CI `.github/workflows/ci.yml`	push, demande de fusion	ci `ubuntu-latest` actions/checkout · Rust setup · Check format · Clippy (mathlib) · Test (mathlib) · Doc test (mathlib) test-parse `ubuntu-latest` actions/checkout · Rust setup · Test parse (all formats) test-features `ubuntu-latest` actions/checkout · Rust setup · Test with parallel feature · Test with full feature test-gpu `ubuntu-latest` actions/checkout · Rust setup · Test GPU · Build GPU examples typos `ubuntu-latest` actions/checkout · crate-ci/typos security `ubuntu-latest` actions/checkout · Rust setup · Install cargo-audit · Generate lockfile for audit · Audit dependencies coverage `ubuntu-latest` actions/checkout · Rust setup · Install tarpaulin · Run coverage · Upload coverage artifact · Upload to Codecov wasm `ubuntu-latest` actions/checkout · Rust setup · Check WASM build (default features) · Check WASM build (wasm feature) wasm-gpu `ubuntu-latest` actions/checkout · Rust setup · Install wasm-pack · Build WASM with GPU	—
GitHub Pages `.github/workflows/pages.yml`	push	build-and-deploy `ubuntu-latest` actions/checkout · Rust setup · Cache cargo-installed tools · Install Pages tools · Prepare Pages artifact · Setup Pages	GitHub Pages

7.13. Déploiement

Mermaid Schéma de déploiement

flowchart LR
  repo[("Dépôt GitHub")]
  ci[["GitHub Actions<br/>2 workflows"]]
  image["Image Docker<br/>FROM rust:1-bookworm"]
  pub_GitHub_Pages[("GitHub Pages")]
  repo -->|"push ou demande de fusion"| ci
  ci -->|"docker build"| image
  ci -->|"publie"| pub_GitHub_Pages

UML Déploiement

Le nœud extérieur est l’endroit où le code s’exécute. Chaque image de base pointe vers ce qu’elle construit, les flèches pleines mènent aux bases de données et les pointillées aux services externes. Rendu avec uml-mcp.

Source PlantUML

@startuml
skinparam backgroundColor transparent
skinparam shadowing false
skinparam roundCorner 10
skinparam defaultFontName Arial
skinparam defaultFontSize 13
skinparam ArrowColor #4e6070
skinparam ArrowFontColor #3d4f5f
skinparam titleFontSize 14
skinparam actorBorderColor #006a62
skinparam actorBackgroundColor #e9f3f4
skinparam usecaseBorderColor #006a62
skinparam usecaseBackgroundColor #e9f3f4
skinparam componentBorderColor #006a62
skinparam componentBackgroundColor #e9f3f4
skinparam interfaceBorderColor #006a62
skinparam interfaceBackgroundColor #ffffff
skinparam nodeBorderColor #4e6070
skinparam nodeBackgroundColor #f4f8fb
skinparam databaseBorderColor #006a62
skinparam databaseBackgroundColor #ffffff
skinparam cloudBorderColor #4e6070
skinparam cloudBackgroundColor #f0f5fa
skinparam artifactBorderColor #006a62
skinparam artifactBackgroundColor #ffffff
skinparam rectangleBorderColor #b0c2d3
skinparam activityBorderColor #006a62
skinparam activityBackgroundColor #e9f3f4
skinparam partitionBorderColor #b0c2d3
skinparam stereotypeCBackgroundColor #ffffff
node "Image Docker" as H {
  artifact "Dimension" as APP
}
artifact "FROM rust:1-bookworm" as IMG0
IMG0 ..> APP : construit
artifact "FROM nginx:alpine" as IMG1
IMG1 ..> APP : construit
cloud "WebSocket" as E0
APP ..> E0
cloud "Hugging Face" as E1
APP ..> E1
@enduml

Où il s’exécute

Publié vers

GitHub Pages

Images Docker de base

rust:1-bookworm nginx:alpine

7.14. Supervision

Ce que le code consigne, mesure et expose pour savoir s’il fonctionne.

Journalisation Rust

Routes de santé et de métriques

GET /health

7.15. Sécurité

Chaîne d’approvisionnement

Variables d’environnement 3

La page reprend les noms sans leurs valeurs et souligne ceux qui ressemblent à des secrets.

CARGO_CFG_FEATURES CARGO_CFG_TARGET_ARCH MATHLIB_GPU_SIZE

7.16. Tests automatisés

Fichiers de test: 141
Fichiers source: 525
Cas de test, environ: 927
Tests unitaires: 135
Tests de bout en bout: 4
Tests intégration: 2

Couverture de code

Aucun rapport chiffré de couverture dans les sources analysées.

Où sont les tests

mathlib/tests/wasm 15 parse/tests 14 mathlib/tests/cg 10 mathlib/tests/graph 10 mathlib/tests/linear 10 mathlib/tests/optimisation/argmin 8

Intégration continue

CI: clippy, cargo test

UML Pipeline CI

Le workflow GitHub Actions principal suit ces étapes. Les tâches lancées en parallèle sont côte à côte. Rendu avec uml-mcp.

Source PlantUML

@startuml
skinparam backgroundColor transparent
skinparam shadowing false
skinparam roundCorner 10
skinparam defaultFontName Arial
skinparam defaultFontSize 13
skinparam ArrowColor #4e6070
skinparam ArrowFontColor #3d4f5f
skinparam titleFontSize 14
skinparam actorBorderColor #006a62
skinparam actorBackgroundColor #e9f3f4
skinparam usecaseBorderColor #006a62
skinparam usecaseBackgroundColor #e9f3f4
skinparam componentBorderColor #006a62
skinparam componentBackgroundColor #e9f3f4
skinparam interfaceBorderColor #006a62
skinparam interfaceBackgroundColor #ffffff
skinparam nodeBorderColor #4e6070
skinparam nodeBackgroundColor #f4f8fb
skinparam databaseBorderColor #006a62
skinparam databaseBackgroundColor #ffffff
skinparam cloudBorderColor #4e6070
skinparam cloudBackgroundColor #f0f5fa
skinparam artifactBorderColor #006a62
skinparam artifactBackgroundColor #ffffff
skinparam rectangleBorderColor #b0c2d3
skinparam activityBorderColor #006a62
skinparam activityBackgroundColor #e9f3f4
skinparam partitionBorderColor #b0c2d3
skinparam stereotypeCBackgroundColor #ffffff
title CI
start
fork
  partition "ci" {
    :actions/checkout;
    :Rust setup;
    :Check format;
    :Clippy (mathlib);
    :Test (mathlib);
    :Doc test (mathlib);
    :Build examples (mathlib);
  }
fork again
  partition "test-parse" {
    :actions/checkout;
    :Rust setup;
    :Test parse (all formats);
  }
fork again
  partition "test-features" {
    :actions/checkout;
    :Rust setup;
    :Test with parallel feature;
    :Test with full feature;
  }
fork again
  partition "test-gpu" {
    :actions/checkout;
    :Rust setup;
    :Test GPU;
    :Build GPU examples;
  }
fork again
  partition "typos" {
    :actions/checkout;
    :crate-ci/typos;
  }
end fork
stop
@enduml

8. Types et structure des fichiers

430 types déclarés, dont 12 dans l’aperçu des relations de base.

Diagramme des types

classDiagram
direction TB
class t4a5cd93435e6["Aabb"] {
  <<struct>>
  new()
  corners()
  union()
  union_many()
}
class t00c318d02aea["Aabb2"] {
  <<struct>>
  new()
  from_center_half_extents()
  corners()
  intersects()
}
class tdf807751b6f7["BspNode"] {
  <<enum>>
}
class tc84a8c5a51f3["BspTree"] {
  <<struct>>
}
class t03c92090f7e7["BvhBuildStrategy"] {
  <<enum>>
}
class t8b7035050ae2["BvhNode"] {
  <<enum>>
}
class t4cf1ac3511d5["BvhTree"] {
  <<struct>>
}
class t2f72a336b45d["BvhRayIter"] {
  <<struct>>
}
class t0f551e8e9c62["BvhFrustumIter"] {
  <<struct>>
}
class tb5166a8a85e0["Capsule"] {
  <<struct>>
  new()
  aabb()
  ray_intersect()
}
class t39e7bad6e68e["Circle"] {
  <<struct>>
  new()
  aabb()
  contains_point()
  ray_intersect()
}
class ta681312b5c13["Frustum"] {
  <<struct>>
  from_view_proj()
  intersects_aabb()
}

Les bases non résolues restent identifiées; les signatures complètes ne sont pas reconstruites.

9. Référence

660 / 660 fichiers admissibles lus (800 dans l’arbre); 0 trop volumineux, 0 échec de lecture et 0 diagnostic de syntaxe.

Ce que couvre l’analyse

Les dossiers connus de dépendances et de compilation, les fichiers d’identifiants et les binaires sont exclus. La collecte couvre les README, les manifestes reconnus et les fichiers source pris en charge.

Les statistiques Linguist couvrent l’ensemble du dépôt et peuvent inclure d’autres langages.

11. Fichiers à lire 3

12. Glossaire

Dépôt

Les fichiers source, la configuration et l’historique versionné d’un projet.

README

Le document d’entrée du dépôt, qui présente généralement son rôle et son installation.

Dépendance

Une bibliothèque, un outil ou un service nécessaire à la compilation ou à l’exécution d’un composant.

API

Une interface par laquelle des composants logiciels échangent des requêtes et des résultats. Une API n’utilise pas nécessairement HTTP.

Conteneur

Un environnement de processus isolé créé à partir d’une image. Les données persistantes nécessitent un stockage hors de son système de fichiers temporaire.

Volume et montage de dossier

Un volume est un stockage géré par la plateforme de conteneurs ; un montage de dossier expose un chemin de l’hôte dans un conteneur.

Port publié

Un port de l’hôte associé au port d’un service dans un conteneur. Sa publication peut rendre le service accessible hors du réseau des conteneurs.

Interface en ligne de commande

Une interface textuelle où les commandes et arguments choisissent les opérations. Les codes de retour permettent aux scripts de détecter un succès ou un échec.

Compilation

Les étapes qui transforment les sources et dépendances en programme exécutable ou en livrable distribuable.

GPU

Un processeur conçu pour les calculs parallèles, dont le rendu graphique et de nombreuses opérations numériques.

Shader

Un programme exécuté à une étape d’un pipeline graphique ou de calcul, par exemple pour transformer des sommets ou calculer la couleur des pixels.

Maillage

Une surface représentée par des sommets et des éléments reliés, souvent des triangles. Sa géométrie est distincte de son matériau ou de sa texture.

Détection continue des collisions

Une recherche de contact pendant le mouvement entre deux états, au lieu de tester seulement ses extrémités.

Backend

Une implémentation derrière une interface commune. Selon le contexte, il peut s’agir d’un service côté serveur ou d’une implémentation graphique, d’entrée ou de stockage.

13. Références

antoinebou12. (2026, 5 novembre). Dimension. [Software repository] github.com.
antoinebou12. (2026, 5 novembre). Dimension: README. [Repository documentation] github.com.
antoinebou12. (2026, 5 novembre). Cargo.toml. [Source file] github.com.
antoinebou12. (2026, 5 novembre). mathlib/src/lib.rs. [Source file] github.com.
antoinebou12. (2026, 5 novembre). render/src/lib.rs. [Source file] github.com.
Boucher, A. (2026, 23 octobre). Dimension : relier les mathématiques Rust au rendu. [Project article] antoineboucher.info.
Boucher, A. (2026, 13 avril). Dimension (mathlib). [Project article] antoineboucher.info.
Boucher, A. (2026, 23 octobre). Dimension : Du stockage matriciel à la scène affichée. [Project article] antoineboucher.info.

Les sources sans date de publication indiquent la date de leur dernière vérification, le 5 novembre 2026. Les liens des fichiers conservent la révision inspectée lorsqu’elle est disponible.

1. Aperçu

1.1. Pourquoi il existe

1.2. Cas d’usage

1.3. Articles et retours d’expérience liés

Dimension : relier les mathématiques Rust au rendu

2. Cas d’utilisation

2.1. Scénario : Essayer les démos en local avant de pousser

3. Démarrage

3.1. e2e/package.json

4. Références du dépôt

4.1. Getting started

4.2. Performance / Troubleshooting

4.3. Contributing to Dimension

4.4. Development workflow

4.5. E2E tests (Playwright)

4.6. What the tests do

4.7. E2E tests (Playwright) (README.md)

5. Fonctions et composants 2

6. Architecture

7. Dossier technique

7.1. Couches et modules

7.2. Modèle C4

7.3. Flux de données

7.4. Interface publique

Routes HTTP 4

Ligne de commande 2

Points d’entrée

7.5. Interface privée

7.6. Services

Service 3

7.7. Entités et modèle de données 247

7.8. Logique métier

7.9. Base de données et persistance

7.10. Intégrations externes

Clients HTTP

Hôtes nommés dans le code

7.11. Stack et dépendances

Dépendances externes

7.12. Pipeline CI/CD

7.13. Déploiement

Où il s’exécute

Publié vers

Images Docker de base

7.14. Supervision

Routes de santé et de métriques

7.15. Sécurité

Chaîne d’approvisionnement

Variables d’environnement 3

7.16. Tests automatisés

Couverture de code

Où sont les tests

Intégration continue

8. Types et structure des fichiers

9. Référence

11. Fichiers à lire 3

12. Glossaire

13. Références

3.1. `e2e/package.json`