Pith. sign in

REVIEW 4 major objections 6 minor 40 references

Real-Time Cloth Simulation Using WebGPU: Evaluating Limits of High-Resolution

T0 review · 4 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read WebGPU keeps a mass-spring cloth simulation at 60fps up to 640K nodes, while WebGL falls below real time past 10K.

desk verdict Modest but honest WebGPU-vs-WebGL cloth benchmark that stumbles on a load-bearing ambiguity in the collision workload, making the headline fps claims unverifiable from the text. read the letter →

arxiv 2507.11794 v1 pith:ELBHDGZW submitted 2025-07-15 cs.GR

Nak-Jun Sung , Jun Ma , TaeHeon Kim , Yoo-joo Choi , Min-Hyung Choi , Min Hong This is my paper · ORCID
classification cs.GR
keywords Real-TimeSimulationClothWebGPUGLMass-SpringMethodCollisionDetectionComputeShadersMöller-Trumbore
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to show that WebGPU, the browser graphics API with compute-shader support, can carry real-time cloth simulation at resolutions that WebGL cannot reach. In a hanging-cloth benchmark, a mass-spring solver runs at 60 frames per second with up to 640,000 nodes on WebGPU, whereas WebGL becomes non-interactive beyond roughly 10,000 nodes. The authors then push WebGPU to its limit in collision scenarios: a 4,000-node cloth hitting a 100,000-triangle model sustains 30fps, but higher cloth resolutions collapse to a few frames per second. The point is that WebGPU moves web graphics from rendering-only to general-purpose GPU computation, which matters for browser-based games, virtual try-on, and AR/VR where users cannot install software.

What carries the argument

The mechanism that carries the argument is the WebGPU compute pipeline running a spring-centric mass-spring solver. One thread per spring computes $F = k(\|d\| - L)$ plus a damping term along the spring direction, then uses atomic additions to accumulate equal-and-opposite forces on the two endpoint nodes, so no node-level serialization is needed. Collision detection uses an extended Möller-Trumbore test, a segment-triangle intersection routine that reports where along a cloth edge the surface triangle is hit, and collision response stores per-vertex response directions in atomic buffers and applies their average when updating positions. This combination lets a browser execute the per-spring physics and per-edge collision workload in parallel, which is exactly what WebGL's rendering-only shader model cannot do.

What would settle it

Instrument the WebGPU pipeline to time only the collision-detection dispatch for the 4K-node cloth against the 100K-triangle Dragon model and add a counter for dispatched edge-triangle pairs. If the pair count is less than (cloth edges × 100,000) or the collision pass alone exceeds about 33ms per frame on the reported RTX 4070 Ti, the all-pairs 30fps claim does not hold as stated.

Watch

Extended reading notes

Core claim

The paper's central claim is that WebGPU's compute pipeline, combined with a spring-centric mass-spring solver, makes high-resolution cloth simulation practical in a web browser. Each spring is handled by one GPU thread, which computes Hooke's law and damping forces and accumulates the result with atomic writes into a temporary force buffer; collision detection then applies an extended Möller-Trumbore edge-triangle intersection test, and collision response averages the detected directions before updating positions. With this pipeline the paper reports 60fps at 640K nodes in the gravity-only hanging scene, and 30fps when a 4K-node cloth collides with the 100K-triangle Dragon model. The same experiments expose the current limit: collision handling without spatial acceleration drops to 3.05fps at 65.5K nodes against the Armadillo model and 7.47fps at 16.3K nodes against the Dragon model.

Load-bearing premise

The load-bearing premise is that the collision loop in Section 4.2 really tests every cloth edge against every surface triangle each frame with no spatial acceleration, because the reported 30fps otherwise implies more edge-triangle tests per second than the hardware plausibly sustains.

Editorial extensions

If this is right

  • Browser-based cloth applications can run at full frame rate with roughly 640K mass-spring nodes, a resolution that previously required native installs.
  • Equal 60fps performance needs about 160 times fewer nodes on WebGL than on WebGPU for this workload.
  • Real-time collision with high-detail surfaces is attainable only at low cloth resolution (4K nodes for the 100K-triangle model), so visual detail and real-time response must still be traded off.
  • Without collision culling, the brute-force approach hits a wall: 65.5K cloth nodes against 50K triangles runs at 3.05fps, making acceleration structures the obvious next step.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The paper does not claim it, but the same compute-shader force-accumulation pattern should port to position-based dynamics or projective dynamics, since those solvers also reduce to parallel constraint updates; the authors list these as future work.
  • The paper attributes the 640K-node ceiling to a 128MB buffer allocation limit; if so, that ceiling is a memory-cap artifact rather than a measured throughput limit, and larger buffers or chunked accumulation could raise it on other devices.
  • A reader should not generalize the 30fps collision result to other cloth topologies: the all-pairs workload scales with the number of cloth edges multiplied by the number of surface triangles, so a mesh with more springs per node will hit the same performance wall at lower node counts.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 6 minor

Summary. The paper presents a WebGPU-based cloth simulation system using a mass-spring model with spring-centric compute shaders, collision detection via an extended Möller–Trumbore test, and per-vertex collision response. It reports two sets of experiments: (1) a hanging-cloth comparison between WebGPU and WebGL, claiming that WebGPU maintains 60fps with up to 640K cloth nodes while WebGL struggles beyond 10K nodes; and (2) a collision benchmark between cloth and three 3D surface models (Sphere, Armadillo, Dragon), claiming that WebGPU sustains 30fps for a 4K-node cloth against a 100K-triangle Dragon model. The authors release their source code on GitHub.

Significance. If the performance results are reproducible, the paper provides a useful data point for WebGPU's applicability to real-time physics simulation in the browser, and the release of source code is a positive contribution. The comparison with WebGL, however, conflates API differences with implementation differences, and the collision experiment's workload as described is inconsistent with the reported frame rates. As written, the quantitative claims cannot be accepted without substantial clarification and additional measurement detail.

major comments (4)
  1. [Section 4.2 / Section 3] The reported 30fps for a 4K-node cloth colliding with a 100K-triangle Dragon model is inconsistent with the collision pipeline as described. Section 3 states "When collision check for all triangle pairs is completed" and Section 5 lists collision culling as future work, implying brute-force all-pairs testing. A 4K-node regular grid contains roughly 8,000 triangles and roughly 12,000 springs; all-pairs edge-triangle tests would require approximately 0.8–1.2 billion intersection tests per frame. At 30fps this is 2.4–3.6×10^10 tests per second, far beyond the capabilities of an RTX 4070 Ti for Möller–Trumbore-style tests without broad-phase acceleration. The authors must clarify whether a spatial acceleration structure, bounding-box prefilter, or early-out is actually used in the measured code. If none is used, the fps values need to be re-measured and reported together with a per-frame timing breakdown.
  2. [Sections 4.1 and 4.2] The performance measurements lack the statistical and methodological detail expected for a benchmark claim. There are no error bars, no number of repeated runs, no statement about vsync or frame pacing, no warm-up procedure, and no description of how the fps number is computed (e.g., average over N frames, 99th percentile, or instantaneous). Moreover, the WebGL baseline uses the Three.js library while the WebGPU implementation appears to be a custom implementation; this conflates API-level differences with library and implementation overhead. A fair comparison would use comparable implementations or, at minimum, report the implementation details for both.
  3. [Section 3] The collision detection algorithm is described inconsistently. The text first says the system employs "triangle-triangle intersection," but the Extended Möller–Trumbore Process is then specified for an edge with endpoints S and E against a triangle with vertices V0, V1, V2, and Algorithm 2 applies the response per cloth vertex. These are different workloads with different computational costs and different response aggregation. The paper must state precisely which primitive pairs are tested per thread and how the per-vertex response is accumulated; otherwise the experiment cannot be reproduced and the claimed frame rates cannot be assessed.
  4. [Section 4.2] The scaling behavior of the collision experiments is not reported in full. The text gives only selected points (the resolution at which 30fps is achieved and the maximum resolution before performance collapses), with no fps-versus-resolution curves or tables for the Sphere, Armadillo, and Dragon models. Reporting the complete series, including standard deviations, is necessary both to support the "limits of real-time" claim and to allow readers to verify the monotonic degradation described in the text.
minor comments (6)
  1. [Abstract] The phrase "between 4K and 100k cloth node models" is ambiguous; the experiments use 4K and up to 65.5K cloth nodes, not 100K.
  2. [Section 4.1 / Figure 6] There are several typos: "Evnrionment" in Section 4.1, "Haning" in Figure 6, and "T able" in the table captions.
  3. [Section 5] The sentence "If the cloth model resolution exceeded this threshold, this was generated, the simulation performance degraded to the extent..." is ungrammatical and should be rewritten.
  4. [Section 2.2] The word "Additionaly" should be "Additionally."
  5. [References] Reference [1] appears truncated (the URL is cut off), and several entries lack complete information.
  6. [General] The paper should specify whether the reported fps include rendering or only the simulation/compute pass, since the WebGL comparison may be dominated by rendering cost rather than simulation.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity: benchmark claims are externally grounded; overlapping-author citations are for context/future work and not load-bearing.

full rationale

The paper's central results are empirical performance measurements (fps on a fixed hardware stack, Table 2) comparing a WebGPU mass-spring implementation against a WebGL baseline, not quantities derived from fitted parameters or from the paper's own definitions. The MSS force computation (Algorithm 1) and extended Möller-Trumbore collision test are standard algorithms with stated inputs; no parameter is fit to a subset of data and then renamed a prediction. The one overlapping-author citation used in the Discussion ([33], for barycentric-coordinate optimization) is explicitly future work and does not support any load-bearing step. Reference [2], also by overlapping authors, is only a related-work pointer. The Section 3 versus Section 5 tension about collision culling (all-pairs triangle-triangle versus planned culling) is a potential correctness/reporting concern about plausibility of the 30fps number, but it is not circularity: even if the workload description is inaccurate, the claim would be a measurement or reporting error rather than the output reducing to the input by construction. Thus no circular step is identified.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

No free parameters are fitted; the simulation constants (stiffness, damping) are not used to make predictions. The claims rest on standard physics and intersection algorithms plus the availability of WebGPU compute shaders.

assumptions (4)
  • standard math Hooke's law models spring forces
    Used in Algorithm 1 to compute spring forces.
  • standard math Euler integration approximates position updates
    Mentioned in Section 3 for predicting next position.
  • standard math Moller-Trumbore intersection detects collisions
    Extended in Section 3 for edge-triangle tests.
  • domain assumption WebGPU compute shaders execute on GPU
    The entire performance claim assumes compute shaders are available and fast in Chrome 122.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Real-Time Cloth Simulation Using WebGPU: Evaluating Limits of High-Resolution." pith.science (2026). https://pith.science/paper/ELBHDGZW

@misc{pith2026250711794,
  author       = {Pith},
  title        = {Pith review of: Real-Time Cloth Simulation Using WebGPU: Evaluating Limits of High-Resolution},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ELBHDGZW}},
  note         = {Machine review of arXiv:2507.11794}
}
read the original abstract

This study explores the capabilities of WebGPU, an emerging web graphics paradigm, for real-time cloth simulation. Traditional WebGL-based methods have been in handling complex physical simulations due to their emphasis on graphics rendering rather than general-purpose GPU (GPGPU) operations. WebGPU, designed to provide modern 3D graphics and computational capabilities, offers significant improvements through parallel processing and support for computational shaders. In this work, we implemented a cloth simulation system using the Mass-Spring Method within the WebGPU framework, integrating collision detection and response handling with the 3D surface model. First, comparative performance evaluations demonstrate that WebGPU substantially outperforms WebGL, particularly in high-resolution simulations, maintaining 60 frames per second (fps) even with up to 640K nodes. The second experiment aimed to determine the real-time limitations of WebGPU and confirmed that WebGPU can handle real-time collisions between 4K and 100k cloth node models and a 100K triangle surface model in real-time. These experiments also highlight the importance of balancing real-time performance with realistic rendering when handling collisions between cloth models and complex 3D objects. Our source code is available at https://github.com/nakjun/Cloth-Simulation-WebGPU

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

40 extracted references · 39 canonical work pages

  1. [1]

    arXiv preprint arXiv:2403.19272 (2024)

    Lan, L., Lu, Z., Long, J., Yuan, C., Li, X., He, X., Wang, H., Jiang, C., Yang, Y.: Efficient GPU Cloth Simulation with Non-distance Barriers and Subspace Reuse. arXiv preprint arXiv:2403.19272 (2024). https://arxiv.org/abs/2403.1927

    arXiv 2024

  2. [2]

    Va, H., Choi, M.-H., Hong, M.: Real-time cloth simulation using compute shader in unity3d for ar/vr contents. Appl. Sci. 11, 8255 (2021)

    work page 2021

  3. [3]

    In: El Rhalibi, A., Tian, F., Pan, Z., Liu, B

    Tang, W., Sagi, A., Green, D., Wan, T.R.: Cross-platform cloth simulation api for games. In: El Rhalibi, A., Tian, F., Pan, Z., Liu, B. (eds.) E-Learning and Games, pp. 224–232. Springer, Cham (2016)

    work page 2016

  4. [4]

    In: Eurographics/ ACM SIGGRAPH Symposium on Computer Animation (2012)

    Kim, T.-Y., Chentanez, N., M¨ uller-Fischer, M.: Long range attachments - a method to simulate inextensible clothing in computer games. In: Eurographics/ ACM SIGGRAPH Symposium on Computer Animation (2012)

    work page 2012

  5. [5]

    Computer-Aided Design 167, 103638 (2024)

    Dai, X., Hong, Y.: Fabric mechanical parameters for 3d cloth simulation in apparel cad: A systematic review. Computer-Aided Design 167, 103638 (2024)

    work page 2024

  6. [6]

    Dress Anyone : Automatic Physically-Based Garment Pattern Refitting

    Chen, H.-y., Larionov, E., Kavan, L., Lin, G., Roble, D., Sorkine-Hornung, O., Stuyck, T.: Dress anyone : Automatic physically-based garment pattern refitting. arXiv preprint arXiv:2405.19148 (2024)

    work page Pith review arXiv 2024

  7. [7]

    ACM Transactions on Graphics 41(4), 63–114 (2022)

    Wu, B., Wang, Z., Wang, H.: A gpu-based multilevel additive schwarz precondi- tioner for cloth and deformable body simulation. ACM Transactions on Graphics 41(4), 63–114 (2022)

    work page 2022

  8. [8]

    N-Cloth: Predicting 3D Cloth Deformation with Mesh-Based Networks

    Li, Y., Tang, M., Yang, Y., Huang, Z., Tong, R., Yang, S., Li, Y., Manocha, D.: N- cloth: Predicting 3d cloth deformation with mesh-based networks. arXiv preprint arXiv:2112.06397 (2021)

    work page Pith review arXiv 2021

Show all 40 references
  1. [9]

    Rzepka, D.: Cloth simulation in a web browser using webgl and webassembly (2020)

    2020

  2. [10]

    ACM SIGGRAPH 2022 Courses, 1–184 (2022)

    Kenwright, B.: Introduction to the webgpu api. ACM SIGGRAPH 2022 Courses, 1–184 (2022)

    2022

  3. [11]

    Oregon State University (2016)

    Bailey, M.: Opengl compute shaders. Oregon State University (2016)

    2016

  4. [12]

    KSII Transactions on Internet and Information Systems 17(2), 435–449 (2023) https://doi.org/10.3837/tiis.2023.02

    Fu, Y., Shen, L., Chen, T.: 3d-distortion based rate distortion optimization for video-based point cloud compression. KSII Transactions on Internet and Information Systems 17(2), 435–449 (2023) https://doi.org/10.3837/tiis.2023.02. 008

    2023 doi

  5. [13]

    Fransson, E., Hermansson, J.: Performance comparison of WebGPU and WebGL in the Godot game engine (2023) 14

    2023

  6. [14]

    webgpu: A performance analysis for web 3.0

    Chickerur, S., et al.: Webgl vs. webgpu: A performance analysis for web 3.0. Procedia Computer Science 233, 919–928 (2024)

    2024

  7. [15]

    Usta, Z.: Webgpu: A new graphic api for 3d webgis applications. The Inter- national Archives of the Photogrammetry, Remote Sensing and Spatial Infor- mation Sciences XL VIII-4/W9-2024, 377–382 (2024) https://doi.org/10.5194/ isprs-archives-XL VIII-4-W9-2024-377-2024

    2024

  8. [16]

    PhD thesis, Technische Universit¨ at Wien (2023)

    Peter, B.: Particle system in webgpu. PhD thesis, Technische Universit¨ at Wien (2023)

    2023

  9. [17]

    In: Proceedings of the 25th Annual Conference on Computer Graphics and Interactive Techniques, pp

    Baraff, D., Witkin, A.: Large steps in cloth simulation. In: Proceedings of the 25th Annual Conference on Computer Graphics and Interactive Techniques, pp. 43–54 (1998)

    1998

  10. [18]

    In: Proceedings of the 14th Annual Conference on Computer Graphics and Interactive Techniques, pp

    Terzopoulos, D., Platt, J., Barr, A., Fleischer, K.: Elastically deformable mod- els. In: Proceedings of the 14th Annual Conference on Computer Graphics and Interactive Techniques, pp. 205–214 (1987)

    1987

  11. [19]

    In: Computer Animation and Simulation’95: Proceedings of the Eurographics Workshop in Maastricht, The Netherlands, September 2–3, 1995, pp

    Louchet, J., Provot, X., Crochemore, D.: Evolutionary identification of cloth ani- mation models. In: Computer Animation and Simulation’95: Proceedings of the Eurographics Workshop in Maastricht, The Netherlands, September 2–3, 1995, pp. 44–54 (1995). Springer

    1995

  12. [20]

    In: Graphics Interface, pp

    Provot, X.: Deformation constraints in a mass-spring model to describe rigid cloth behaviour. In: Graphics Interface, pp. 147–147 (1995). Canadian Information Processing Society

    1995

  13. [21]

    ACM Transactions on Graphics (TOG) 32(6), 1–7 (2013)

    Liu, T., Bargteil, A.W., O’Brien, J.F., Kavan, L.: Fast simulation of mass-spring systems. ACM Transactions on Graphics (TOG) 32(6), 1–7 (2013)

    2013

  14. [22]

    Journal of Visual Communication and Image Representation 18(2), 109–118 (2007)

    M¨ uller, M., Heidelberger, B., Hennix, M., Ratcliff, J.: Position based dynam- ics. Journal of Visual Communication and Image Representation 18(2), 109–118 (2007)

    2007

  15. [23]

    The Visual Computer 40, 4737–4749 (2024)

    Saillant, B., Zara, F., Damiand, G.e.a.: High-order elements in position-based dynamics. The Visual Computer 40, 4737–4749 (2024)

    2024

  16. [24]

    In: Proceedings of the 9th International Conference on Motion in Games, pp

    Macklin, M., M¨ uller, M., Chentanez, N.: Xpbd: position-based simulation of com- pliant constrained dynamics. In: Proceedings of the 9th International Conference on Motion in Games, pp. 49–54 (2016)

    2016

  17. [25]

    The Visual Computer 15(2), 90–99 (1999)

    Tan, S.T., Wong, T.N., Zhao, Y.F., Chen, W.J.: A constrained finite element method for modeling cloth deformation. The Visual Computer 15(2), 90–99 (1999)

    1999

  18. [26]

    In: 11th Pacific Conference on Computer Graphics and Applications,

    Etzmuß, O., Keckeisen, M., Straßer, W.: A fast finite element solution for cloth 15 modelling. In: 11th Pacific Conference on Computer Graphics and Applications,

  19. [27]

    ACM Transactions on Graphics (TOG) 33(4), 154–111 (2014)

    Bouaziz, S., Martin, S., Liu, T., Kavan, L., Pauly, M.: Projective dynamics: fusing constraint projections for fast simulation. ACM Transactions on Graphics (TOG) 33(4), 154–111 (2014)

    2014

  20. [28]

    ACM Transactions on Graphics (TOG) 43(4), 1–16 (2024)

    Chen, A.H., et al.: Vertex block descent. ACM Transactions on Graphics (TOG) 43(4), 1–16 (2024)

    2024

  21. [29]

    The Visual Computer (2024)

    Chen, Y., Cao, Y., Fang, F.e.a.: Sacanet: end-to-end self-attention-based network for 3d clothing animation. The Visual Computer (2024)

    2024

  22. [30]

    Journal of Graphics Tools 2(2), 25–30 (1997)

    M¨ oller, T.: A fast triangle-triangle intersection test. Journal of Graphics Tools 2(2), 25–30 (1997)

    1997

  23. [31]

    In: ACM SIGGRAPH 2005 Courses (2005)

    M¨ oller, T., Trumbore, B.: Fast, minimum storage ray/triangle intersection. In: ACM SIGGRAPH 2005 Courses (2005)

    2005

  24. [32]

    In: Proceedings of 2012 2nd International Conference on Computer Science and Network Technology, pp

    Zhang, L., Hongzhou, J.: Variable step euler method for real-time simulation. In: Proceedings of 2012 2nd International Conference on Computer Science and Network Technology, pp. 2006–2010 (2012). IEEE

    2012

  25. [33]

    KSII Transactions on Internet and Information Systems (TIIS) 12(8), 4072–4089 (2018)

    Sung, N.-J., Transue, S., Kim, M., Choi, Y.-J., Choi, M.-H., Hong, M.: Optimiza- tion of material properties for coherent behavior across multi-resolution cloth models. KSII Transactions on Internet and Information Systems (TIIS) 12(8), 4072–4089 (2018)

    2018

  26. [34]

    In: Proceedings of the ACM Symposium on Virtual Reality Software and Technology, pp

    Govindaraju, N.K., Lin, M.C., Manocha, D.: Fast and reliable collision culling using graphics hardware. In: Proceedings of the ACM Symposium on Virtual Reality Software and Technology, pp. 2–9 (2004)

    2004

  27. [35]

    ACM Transactions on Graphics (TOG) 29(6), 1–8 (2010)

    Liu, F., et al.: Real-time collision culling of a million bodies on graphics processing units. ACM Transactions on Graphics (TOG) 29(6), 1–8 (2010)

    2010

  28. [36]

    ACM Transactions on Graphics (TOG)26(3), 15 (2007)

    Zhang, X., et al.: Continuous collision detection for articulated models using taylor models and temporal culling. ACM Transactions on Graphics (TOG)26(3), 15 (2007)

    2007

  29. [37]

    ACM Transactions on Graphics (TOG) 29(4), 1–9 (2010)

    Barbiˇ c, J., James, D.L.: Subspace self-collision culling. ACM Transactions on Graphics (TOG) 29(4), 1–9 (2010)

    2010

  30. [38]

    IEEE Journal on Robotics and Automation 4(2), 193–203 (1988)

    Gilbert, E.G., Johnson, D.W., Keerthi, S.S.: A fast procedure for computing the distance between complex objects in three-dimensional space. IEEE Journal on Robotics and Automation 4(2), 193–203 (1988)

    1988

  31. [39]

    Montaut, L., al.: Gjk++: Leveraging acceleration methods for faster collision detection. IEEE Transactions on Robotics (2024) 16 7 Appendix 7.1 Spring-centric Cltoh Simulation Algorithm Algorithm 1, computes the forces exerted by each spring connecting two nodes based on Hooke...

    2024

  32. [2003]

    244–251 (2003)

    Proceedings., pp. 244–251 (2003). IEEE

    2003

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.