SoftAct: Modular Frameworks in Diverse Domains

• SoftAct is a term used to designate modular, geometry-aware computational frameworks that bridge complex physical models with scalable simulations across diverse research areas.
• It emphasizes numeric and interactive simulation methods—such as adaptive Runge–Kutta integration and geodesic contact weighting—to manage state-dependent nonlinearity.
• Applications of SoftAct range from high-energy physics tracking and force-aware soft-hand manipulation to interactive active matter modeling and the control of fiber-reinforced continuum actuators.

SoftAct is a label used in multiple contemporary research contexts rather than a single canonical method. In the literature considered here, it denotes or characterizes four distinct but technically related strands: the Acts tracking framework as a software-first architecture for charged-particle reconstruction at the High-Luminosity Large Hadron Collider; a contact- and force-centric retargeting framework for transferring human manipulation skills to pneumatically actuated soft robot hands; a modeling idiom for soft active matter implemented with Mechanica; and a simulation-and-validation pipeline for assemblies of fiber-reinforced soft actuators (Ai, 2020, Yoo et al., 1 Apr 2026, Somogyi et al., 2021, Kim et al., 14 Jul 2025). The term therefore functions less as a single proper noun than as a recurring designation for frameworks that prioritize modular abstractions, geometry-aware reasoning, and computation under strong physical or architectural constraints.

1. Terminological scope and principal usages

In the cited sources, “SoftAct” spans high-energy-physics software, soft-robot manipulation, biological active-matter simulation, and continuum soft-actuator modeling. The underlying objects differ substantially—tracks, contact patches, particles, and Cosserat rods—but each usage emphasizes a formal computational layer that mediates between complex physical structure and scalable execution.

Usage of “SoftAct”	Domain	Core technical emphasis
Acts as “SoftAct”	HEP track reconstruction	Experiment-independent, thread-safe, hardware-aware tracking software
SoftAct framework	Soft robotic manipulation	Two-stage force-aware retargeting with geodesic-weighted contact refinement
SoftAct with Mechanica	Biological physics and active matter	Real-time interactive particle-based mechanics, transport, reactions, and topology
SoftAct for FREE assemblies	Soft continuum arms	Cosserat-rod simulation, video-based reconstruction, and digital-twin control

A direct implication of this multiplicity is that “SoftAct” is not restricted to soft robotics. One cited usage explicitly applies it to Acts, where it “aptly characterizes Acts as a software-first, architecture-conscious framework for tracking” (Ai, 2020). Other usages are centered on soft or active matter and on soft actuation in the mechanical sense (Yoo et al., 1 Apr 2026, Somogyi et al., 2021, Kim et al., 14 Jul 2025).

2. SoftAct as software-first tracking: the Acts framework

In high-energy physics, the “SoftAct” characterization refers to Acts (“A Common Tracking Software”), which addresses the scaling pressures of the HL-LHC. At HL-LHC instantaneous luminosity, $O(200)$ pile-up interactions per bunch crossing lead to environments with up to about 10,000 charged particles per event, driving a roughly fivefold increase in track reconstruction time relative to current LHC conditions. Acts is designed for these conditions by extracting and generalizing core ideas from ATLAS tracking into an experiment-independent library, decoupled from detector specifics and magnetic-field configuration, while enforcing strict thread-safety, const-correctness, and stateless tools (Ai, 2020).

The architectural core is a detector-agnostic, surface-based geometry. Acts defines Acts::Surface objects such as Plane, Disc, Cylinder, Cone, Straw, and Perigee, with shape bounds via Acts::SurfaceBounds and hierarchical composition into Acts::Layer and Acts::TrackingVolume. Material can be mapped onto surfaces or volumes, and detector geometry can be bridged through Acts::DetectorElementBase, with plugins for TGeo and DD4hep. This geometry directly informs the event data model. Track parameters are represented both in global form,

$G = (\vec{X},\, t,\, \hat{T},\, q/p),$

and in local surface coordinates,

$L = (l_0,\, l_1,\, \phi,\, \theta,\, q/p,\, t).$

Local parameters can be carried by Acts::SingleBoundTrackParameters or Acts::SingleCurvilinearTrackParameters, while measurements are templated through Acts::Measurement, and combinatorial branching is stored in Acts::MultiTrajectory (Ai, 2020).

Propagation and fitting are formulated numerically rather than through a helical state parameterization. Acts::Propagator integrates equations of motion in arbitrary magnetic fields and material distributions, using the adaptive Runge–Kutta–Nyström method as the primary numerical integrator. Covariance transport follows the Jacobian update

$$\mathbf{P}_{k+1} = \mathbf{F}_k \mathbf{P}_k \mathbf{F}_k^\top + \mathbf{Q}_k,$$

with $\mathbf{Q}_k$ capturing material effects. Acts::KalmanFitter is agnostic to field, geometry, parameterization, and measurement representation; smoothing uses the Rauch–Tung–Striebel method or reverse-direction propagation. Track building is handled by Acts::CombinatorialKalmanFilter, which performs on-the-fly measurement search and branching when multiple compatible measurements are present on a surface (Ai, 2020).

The framework’s concurrency model is central to the “SoftAct” designation. Conditions such as alignments, calibrations, and magnetic-field status are supplied by the host experiment via context or payload objects passed through the call chain, so Acts does not own the conditions yet guarantees per-thread, per-event correctness. Templates minimize virtual interfaces and enable inlining and specialization. The codebase is written in modern C++17, uses Eigen as the only hard dependency, and has explored event-level parallelism, intra-event parallelism, and GPU prototypes (Ai, 2020).

Reported performance establishes the practical intent of this software architecture. The paper gives an average Kalman fitting time of approximately $0.2$ ms per track on an Intel i7-8559U with Rauch–Tung–Striebel smoothing. For single muons with $p_T$ $0.1$–$1$ GeV and $|\eta|<2.5$, technical fitting efficiency reaches approximately $G = (\vec{X},\, t,\, \hat{T},\, q/p),$0. In $G = (\vec{X},\, t,\, \hat{T},\, q/p),$1 events with $G = (\vec{X},\, t,\, \hat{T},\, q/p),$2, the Combinatorial KF track finding achieves approximately $G = (\vec{X},\, t,\, \hat{T},\, q/p),$3 efficiency in central $G = (\vec{X},\, t,\, \hat{T},\, q/p),$4 and fake rate $G = (\vec{X},\, t,\, \hat{T},\, q/p),$5, with tracks and truth requiring at least nine hits. GPU seeding shows about $G = (\vec{X},\, t,\, \hat{T},\, q/p),$6 speed-up versus CPU on an NVIDIA GTX1070 compared to an Intel i7-5820K at up to $G = (\vec{X},\, t,\, \hat{T},\, q/p),$7k hits, and propagation prototypes on NVIDIA V100 also show speed gains relative to single-thread CPU baselines (Ai, 2020).

Within this usage, “SoftAct” denotes a modern software architecture for tracking: modular, scalable, experiment-independent, and explicitly engineered for concurrency and hardware heterogeneity. The cited paper also identifies open directions, including navigator simplification, improved memory locality, more sophisticated treatment of non-linear measurements, “free parameter” fitting modes, Kalman-based alignment, and broader accelerator support (Ai, 2020).

3. SoftAct as force-aware retargeting for soft robot policies

In soft robotics, SoftAct is a specific framework for transferring human manipulation skills to non-anthropomorphic, pneumatically actuated soft robot hands. Its central hypothesis is that the transferable structure in dexterous manipulation is contact geometry and force distribution, not kinematics. The framework therefore retargets demonstrations by explicitly modeling where and how the human hand applies contact and how those contacts distribute forces across time and surface geometry, rather than by matching human joint trajectories or fingertip poses (Yoo et al., 1 Apr 2026).

Demonstrations are captured in immersive VR using Unreal Engine. Human hand kinematics are recorded with an OptiTrack system with 10 cameras and 24 markers on the demonstrator’s right hand and streamed into a calibrated kinematic hand model. Object poses are logged in the same world frame, and the VR physics engine records dense hand-object contact points and per-contact force vectors at each timestep. In the real system, object poses are obtained through reflective motion-capture markers, while tactile or contact force sensing is not required on the robot hand. Chamber pressures are controlled at $G = (\vec{X},\, t,\, \hat{T},\, q/p),$8 Hz in hardware, and the simulator uses a $G = (\vec{X},\, t,\, \hat{T},\, q/p),$9 ms FEM timestep (Yoo et al., 1 Apr 2026).

The retargeting algorithm is two-stage. Stage 1 performs force attribution and allocation. Human contact forces are diffused over the hand surface using a geodesic heat kernel on the triangular mesh $L = (l_0,\, l_1,\, \phi,\, \theta,\, q/p,\, t).$0, with geodesic distance

$L = (l_0,\, l_1,\, \phi,\, \theta,\, q/p,\, t).$1

computed by Dijkstra’s algorithm with Euclidean edge weights. The per-vertex heat is

$L = (l_0,\, l_1,\, \phi,\, \theta,\, q/p,\, t).$2

and the accumulated human finger load is

$L = (l_0,\, l_1,\, \phi,\, \theta,\, q/p,\, t).$3

Robot fingers are then allocated to human finger regions by minimizing the maximum per-region load per assigned robot finger,

$L = (l_0,\, l_1,\, \phi,\, \theta,\, q/p,\, t).$4

A workspace-aware matching step aligns demonstrated fingertip trajectory envelopes to robot reachable workspaces, with assignment cost

$L = (l_0,\, l_1,\, \phi,\, \theta,\, q/p,\, t).$5

and a Hungarian-algorithm solution for the fixed mapping $L = (l_0,\, l_1,\, \phi,\, \theta,\, q/p,\, t).$6 (Yoo et al., 1 Apr 2026).

Stage 2 performs online retargeting with geodesic-weighted contact refinements. For robot fingertip position $L = (l_0,\, l_1,\, \phi,\, \theta,\, q/p,\, t).$7 and demonstrated contacts $L = (l_0,\, l_1,\, \phi,\, \theta,\, q/p,\, t).$8, SoftAct uses

$L = (l_0,\, l_1,\, \phi,\, \theta,\, q/p,\, t).$9

and computes the target adjustment

$$\mathbf{P}_{k+1} = \mathbf{F}_k \mathbf{P}_k \mathbf{F}_k^\top + \mathbf{Q}_k,$$0

The adjusted target $$\mathbf{P}_{k+1} = \mathbf{F}_k \mathbf{P}_k \mathbf{F}_k^\top + \mathbf{Q}_k,$$1 is tracked by the controller. The same update is presented as the minimizer of a weighted least-squares contact objective with trust-region and smoothing terms, subject to reachability, pressure bounds, and compliance constraints (Yoo et al., 1 Apr 2026).

Low-level actuation is handled through a learned per-finger forward model $$\mathbf{P}_{k+1} = \mathbf{F}_k \mathbf{P}_k \mathbf{F}_k^\top + \mathbf{Q}_k,$$2 from chamber pressures to fingertip displacement. Desired fingertip displacement is converted to pressures by a differentiable inverse optimization,

$$\mathbf{P}_{k+1} = \mathbf{F}_k \mathbf{P}_k \mathbf{F}_k^\top + \mathbf{Q}_k,$$3

with reparameterization

$$\mathbf{P}_{k+1} = \mathbf{F}_k \mathbf{P}_k \mathbf{F}_k^\top + \mathbf{Q}_k,$$4

and optimization by Adam, warm-started from the previous solution. The policy level uses a diffusion policy trained in a custom rigid–soft FEM simulator; observations include robot proprioception and object poses, and actions include end-effector displacement, orientation update, and soft-finger torque commands in simulation (Yoo et al., 1 Apr 2026).

The framework is evaluated on six contact-rich tasks: light bulb insertion, light bulb twisting or screwing, paper cup pouring, marker grasping, bottle unscrewing, and box reorienting. For low-level fingertip trajectory tracking on four planar trajectories, the reported $$\mathbf{P}_{k+1} = \mathbf{F}_k \mathbf{P}_k \mathbf{F}_k^\top + \mathbf{Q}_k,$$5-plane metrics are: SoftAct RMSE $$\mathbf{P}_{k+1} = \mathbf{F}_k \mathbf{P}_k \mathbf{F}_k^\top + \mathbf{Q}_k,$$6 mm, mean $$\mathbf{P}_{k+1} = \mathbf{F}_k \mathbf{P}_k \mathbf{F}_k^\top + \mathbf{Q}_k,$$7 mm, max $$\mathbf{P}_{k+1} = \mathbf{F}_k \mathbf{P}_k \mathbf{F}_k^\top + \mathbf{Q}_k,$$8 mm; Direct Linear RMSE $$\mathbf{P}_{k+1} = \mathbf{F}_k \mathbf{P}_k \mathbf{F}_k^\top + \mathbf{Q}_k,$$9 mm; Direct MLP RMSE $\mathbf{Q}_k$0 mm; and Direct KNN RMSE $\mathbf{Q}_k$1 mm. The paper reports RMSE reduction by up to $\mathbf{Q}_k$2 and tracking variance reduction by up to $\mathbf{Q}_k$3 compared to the strongest baselines. At the policy level, simulation success rates over 30 rollouts per task include Paper Cup Pouring $\mathbf{Q}_k$4 versus $\mathbf{Q}_k$5, Light Bulb Insertion $\mathbf{Q}_k$6 versus $\mathbf{Q}_k$7, Marker Grasping $\mathbf{Q}_k$8 versus $\mathbf{Q}_k$9, Bottle Unscrewing $0.2$0 versus $0.2$1, Box Reorienting $0.2$2 versus $0.2$3, and Light Bulb Screwing $0.2$4 versus $0.2$5. Real-world rates over 20 rollouts per task are Paper Cup Pouring $0.2$6 versus $0.2$7, Light Bulb Screwing $0.2$8 versus $0.2$9, and Box Reorienting $p_T$0 versus $p_T$1; confidence intervals and statistical significance are not reported (Yoo et al., 1 Apr 2026).

The ablation results are also central. Stage-only retargeting improves over kinematic-only baselines but underperforms full SoftAct; removing geodesic weighting or force magnitude reduces stability and increases drift. The reported interpretation is that contact geometry and force distribution are essential for effective skill transfer to soft robotic hands and cannot be recovered through kinematic imitation alone (Yoo et al., 1 Apr 2026).

4. SoftAct as interactive modeling of soft active matter with Mechanica

A third usage connects “SoftAct” to Mechanica, a native C++ library with a Python API for real-time, interactive simulation of biological physics and active matter. Mechanica is built on a lattice-free, Lagrangian particle engine that unifies mechanics, transport, reactions, and dynamic topology under a consistent modeling formalism. Its stated targets are the specification bottleneck and the tuning bottleneck in biological and active-matter modeling, approached through engineering-style “read–simulate–display” interactivity (Somogyi et al., 2021).

Mechanica’s scope is broad within mesoscale, agent-based, hybrid particle–chemical systems. Supported examples include cells and tissues, soft spheres, viscoelastic materials, discrete-element aggregates, growth, sorting, mitosis, morphogenesis, bonded networks, dissipative particle dynamics fluids, transport DPD with advected solutes, local reaction networks, Fickian and active fluxes, chemomechanical couplings, and hierarchical Cluster objects for internal substructure. The paper explicitly notes that built-in PDE solvers for active nematic $p_T$2-tensor hydrodynamics or phase-field/Cahn–Hilliard equations are not currently provided, although many soft active behaviors can be approximated through particle-based models, bonded networks, and chemical coupling (Somogyi et al., 2021).

The central mechanical equation is a unified particle force balance,

$p_T$3

For fluids, Mechanica uses DPD interactions, with conservative, dissipative, and random components

$p_T$4

$p_T$5

$p_T$6

For strong-friction systems, overdamped dynamics can be selected, with

$p_T$7

This permits Langevin-like active-matter evolution driven by implicit potentials, random forces, and external active forcing (Somogyi et al., 2021).

Transport and reaction are incorporated at the particle level. The species evolution equation is

$p_T$8

where $p_T$9 is Fickian transport, $0.1$0 is stochastic flux, and $0.1$1 represents local source terms. The framework also computes smoothed number density

$0.1$2

using the cubic spline kernel of Monaghan (2005), enabling density-gated growth and division rules. These ingredients let users compose soft active matter from particles, clusters, bonds, forces, species, and fluxes rather than from a separate DSL (Somogyi et al., 2021).

Mechanica’s “SoftAct” character is especially visible in its interactive runtime. The core is an optimized C++ shared library using task-based parallelism and spatial voxel partitioning; the Python API is implemented in C++ for simplicity and performance. Rendering is OpenGL-based, works on desktop and headless configurations, and integrates with Jupyter. The simulator injects hooks into IPython’s message loop and runs as a background thread in Jupyter, delivering 10–15 fps remote visualization with live model edits and parameter changes taking effect immediately. Reaction-network compilation and substantial GPU acceleration are described as future plans rather than present capabilities (Somogyi et al., 2021).

Example applications include differential-adhesion cell sorting, DPD Poiseuille flow, space-limited cell growth and mitosis, cluster-based cleavage and epiboly-like sheet expansion, and viscoelastic bonded solids with fracture under sinusoidal forcing. The paper frames these examples as evidence that agent-based softness, embedded chemistry, explicit bonds, and interactive tuning provide a practical route for soft active matter prototyping without requiring meshed PDE solvers (Somogyi et al., 2021).

5. SoftAct as modeling and control of fiber-reinforced soft actuators

A fourth usage treats SoftAct as the modeling, simulation, and experimental validation of assemblies of fiber-reinforced elastomeric enclosures (FREEs) for soft continuum arms. The motivating problem is that soft continuum arms promise manipulation in cluttered, uncertain, and delicate environments, but their behavior is strongly nonlinear and mutually coupled within assemblies. The cited framework addresses this through a modular simulation stack in which heterogeneous Cosserat-rod elements represent individual FREEs and their interconnections, combined with Vicon-based reconstruction and digital-twin planning (Kim et al., 14 Jul 2025).

A single FREE is modeled as a hollow cylindrical elastomeric tube reinforced by two helical fiber families. The reported material parameters are approximately $0.1$3 MPa, $0.1$4, and $0.1$5 kg/m$0.1$6. Fabricated FREEs include bending FREEs with $0.1$7 plus a spine, clockwise twist FREEs with $0.1$8, and counterclockwise twist FREEs with $0.1$9, with winding numbers $1$0 for bending and $1$1 for rotation, over a pressure range of $1$2–$1$3 psi (Kim et al., 14 Jul 2025).

The kinematic coupling is imposed through inextensible fiber geometry. If $1$4 and $1$5, the constraint

$1$6

implies

$1$7

Fiber angles update according to

$1$8

Pressure is mapped to resultant axial force and torsional moment through the Bishop-Moser–Krishnan–Kota relations for a general helical FREE, with calibration factor $1$9. For bending FREEs, the model adds an empirical spine-induced bending couple

$|\eta|<2.5$0

with $|\eta|<2.5$1 fitted from experiment (Kim et al., 14 Jul 2025).

The assembly-level model is a Cosserat-rod system. A rod is described by centerline $|\eta|<2.5$2 and orthonormal triad $|\eta|<2.5$3, with balance laws

$|\eta|<2.5$4

$|\eta|<2.5$5

Linear constitutive laws are used,

$|\eta|<2.5$6

with geometry-matched area and second moments. Pressure-induced loads enter as distributed actuation,

$|\eta|<2.5$7

Parallel “gluing” and serial connections are modeled with spring-like translational constraints and restoring torques, while environmental interaction is handled through a Hertzian contact law (Kim et al., 14 Jul 2025).

The simulation backbone is PyElastica. Each FREE is a Cosserat rod, and multi-rod assemblies are built through spring-like force constraints and matrix-log torque constraints. The experimental side uses Vicon at $|\eta|<2.5$8 Hz, with ICP grouping of marker clusters, an $|\eta|<2.5$9 complementary filter for orientation denoising, and a physics-informed Cosserat reconstruction $G = (\vec{X},\, t,\, \hat{T},\, q/p),$00 to estimate continuous posture and strains. For comparison between simulation and measured centerlines, the paper registers rod strains to a common centerline through

$G = (\vec{X},\, t,\, \hat{T},\, q/p),$01

The control strategy is not a closed-loop model-based controller; it is an interactive forward-control paradigm in which a joystick supplies pressure commands to the simulator, the user refines a pressure sequence in the digital twin, and the final sequence is replayed on hardware through SMC valves driven by a Raspberry Pi/ROS2 stack (Kim et al., 14 Jul 2025).

Validation is quantitative across several architectures. For a twist–twist serial pair, relative errors are $G = (\vec{X},\, t,\, \hat{T},\, q/p),$02 tip, $G = (\vec{X},\, t,\, \hat{T},\, q/p),$03 total twist, and $G = (\vec{X},\, t,\, \hat{T},\, q/p),$04 elongation at $G = (\vec{X},\, t,\, \hat{T},\, q/p),$05 psi, and $G = (\vec{X},\, t,\, \hat{T},\, q/p),$06, $G = (\vec{X},\, t,\, \hat{T},\, q/p),$07, and $G = (\vec{X},\, t,\, \hat{T},\, q/p),$08 at $G = (\vec{X},\, t,\, \hat{T},\, q/p),$09 psi. For a bend–bend pair with $G = (\vec{X},\, t,\, \hat{T},\, q/p),$10 spine angle offset, the relative errors are $G = (\vec{X},\, t,\, \hat{T},\, q/p),$11 tip, $G = (\vec{X},\, t,\, \hat{T},\, q/p),$12 total bend, and $G = (\vec{X},\, t,\, \hat{T},\, q/p),$13 elongation at $G = (\vec{X},\, t,\, \hat{T},\, q/p),$14 psi, and $G = (\vec{X},\, t,\, \hat{T},\, q/p),$15, $G = (\vec{X},\, t,\, \hat{T},\, q/p),$16, and $G = (\vec{X},\, t,\, \hat{T},\, q/p),$17 at $G = (\vec{X},\, t,\, \hat{T},\, q/p),$18 psi. For a six-FREE BR2–B3 arm, three postures are reported with tip errors $G = (\vec{X},\, t,\, \hat{T},\, q/p),$19, $G = (\vec{X},\, t,\, \hat{T},\, q/p),$20, and $G = (\vec{X},\, t,\, \hat{T},\, q/p),$21, and all deviations are described as within about $G = (\vec{X},\, t,\, \hat{T},\, q/p),$22–$G = (\vec{X},\, t,\, \hat{T},\, q/p),$23 across metrics. In a constrained reach-and-retrieve task involving insertion through a circular opening, rotation, magnetic grasping of a battery, and retrieval, the exact simulated pressure sequence is replayed on hardware with no manual intervention, achieving success in $G = (\vec{X},\, t,\, \hat{T},\, q/p),$24 trials with small target perturbations (Kim et al., 14 Jul 2025).

The paper also states the framework’s limits: linear elastic rod-space constitutive behavior rather than explicit hyperelasticity, no detailed viscoelasticity or hysteresis model, no pneumatic dynamics or fluid–structure coupling, empirical augmentation for spine-induced bending, and open-loop feedforward control rather than closed-loop observers or MPC (Kim et al., 14 Jul 2025).

6. Comparative interpretation, misconceptions, and open problems

The cited literature indicates that “SoftAct” should not be treated as a unique algorithm, software package, or subfield. It names or characterizes several frameworks whose commonality is structural rather than nominal. A likely source of confusion is the assumption that the term always refers to soft robotic actuation; one of the cited usages instead applies it to Acts, a charged-particle tracking framework for HEP (Ai, 2020). Conversely, in the robotics and mechanics papers, “SoftAct” is literal in the sense of soft actuation, soft hands, or soft active matter (Yoo et al., 1 Apr 2026, Somogyi et al., 2021, Kim et al., 14 Jul 2025).

A plausible unifying interpretation is that these usages share three technical commitments. First, they all privilege modular abstractions over monolithic, problem-specific code: Acts separates geometry, propagation, EDM, and fitting; the soft-hand SoftAct separates force attribution, online retargeting, inverse actuation, and diffusion-policy learning; Mechanica decomposes models into particles, clusters, forces, bonds, species, and fluxes; and the FREE framework composes rods, connectivity constraints, reconstruction, and replay control (Ai, 2020, Yoo et al., 1 Apr 2026, Somogyi et al., 2021, Kim et al., 14 Jul 2025). Second, they all encode geometry as a computational primitive: surface-based detector navigation in Acts, mesh geodesics on hands and objects in robotic retargeting, voxelized spatial neighborhoods and particle topologies in Mechanica, and Cosserat centerlines with director frames in FREE assemblies (Ai, 2020, Yoo et al., 1 Apr 2026, Somogyi et al., 2021, Kim et al., 14 Jul 2025). Third, they all confront state-dependent nonlinearity through explicit numerical machinery rather than through rigid analytic simplification: adaptive Runge–Kutta–Nyström propagation, geodesic heat-kernel weighting, DPD or overdamped stochastic dynamics, and Cosserat-rod integration with state-dependent pressure loads (Ai, 2020, Yoo et al., 1 Apr 2026, Somogyi et al., 2021, Kim et al., 14 Jul 2025).

The open problems are similarly domain-specific but methodologically aligned. Acts identifies extreme-occupancy scaling, improved memory locality, more sophisticated linearization, “free parameter” fitting, Kalman-based alignment, and fuller accelerator integration as active directions (Ai, 2020). The soft-hand SoftAct notes dependence on VR-derived contact forces, short-horizon tasks with fixed interaction structure, reliance on motion capture for object pose, and sensitivity to sensing and calibration noise, with vision-based estimation, tactile sensing, domain randomization, and adaptive estimation as natural extensions (Yoo et al., 1 Apr 2026). Mechanica highlights the absence of built-in PDE solvers for active nematics and phase fields, CPU-side reaction networks, and rendering targets that remain below the intended performance ceiling (Somogyi et al., 2021). The FREE framework identifies missing viscoelasticity, hysteresis, temperature dependence, pneumatic dynamics, richer identification, and closed-loop control as the main omissions (Kim et al., 14 Jul 2025).

Taken together, these sources suggest that “SoftAct” is best understood as a recurrent research motif: a software-centered or computation-centered response to systems whose salient behavior emerges from contact, compliance, active forcing, or combinatorial physical structure. The exact referent changes across fields, but in each case the term is associated with formal abstractions that preserve physically relevant invariants while remaining implementable at scale (Ai, 2020, Yoo et al., 1 Apr 2026, Somogyi et al., 2021, Kim et al., 14 Jul 2025).