Phenix Dev Log

Fixed the Geometry Nodes bake path that was misbehaving on certain setups, so caching simulations to disk now works reliably from the GN side. Closed out the remaining audit polish items for a cleaner overall state heading into the next round of work.

Capped the neighbor search expansion to prevent the viewport freezing when artists pushed extreme radius or cell-size values. Added new audit and graph diagnostics to make these edge cases visible before they bite. Continued polishing fixes flagged by the audit.

Fixed an SPH viscosity bug that was throwing off the look of dense fluid sims. Reworked the particle merge and split logic for cleaner behavior under heavy interaction loads. Improved alignment with Blender’s bake format and continued ironing out audit findings.

Pushed the long audit through to zero pending items, taking 138 tracked issues down to none. Cleared 21 regressions in one sweep, including SPH fluid corrections, neighbor search clamping, and runtime expression sanitization. Build and tests stayed clean across the whole pass.

Completed a 100% audit pass of the codebase, resolving a wide batch of correctness, safety, and documentation issues. Hardened the expression parser, fixed GPU state leakage between frames, and clarified the contract for particle metadata. The audit tracker climbed past 199 fixes with the build staying clean throughout.

Boids can now target an animatable world position when in follow-lead mode, opening up keyframed leader trajectories for swarm shots. Spent time polishing presets and running comparison passes against reference fluid sims to validate behavior. Continued the broader audit pass on the system.

Cleaned up debug prints and tightened the user-facing feedback in the addon. Added clearer warning messages and an error overlay so issues surface where artists can see them. Hardened the external connection layer for safer remote control, and enriched documentation along the way.

Fixed a critical rendering bug — a leftover sentinel value hidden in two shaders has been removed and visuals are now clean. Started a new single image node that handles still images, sequences and video the same way Blender does natively, with stronger automated checks on image and CSV inputs. A new compile-time validation step now catches layout mistakes before they can become runtime issues, and a release was packaged out.

Modernised the internal developer tools so they handle paths and project structure in a more reliable way. Almost the full test suite is now green again — a single failing test remains on the list. Documentation was refreshed alongside to reflect the recent changes.

Tracked down a slow drift in particles meant to stay still, and recalibrated several behaviors after the recent architectural change. A new grab interaction was introduced for direct manipulation in the viewport. An overflow edge case was also closed to keep long simulations stable.

Brought the different parts of the addon into a more consistent shape so they all speak the same language. Added a full set of unit tests for the Blender nodes — they all pass — and tidied up small details like input limits, stable identifiers for spawners and stray UI warnings. Several existing tests were recalibrated to match the new behavior.

Tracked down the source of non-deterministic results — the same simulation now produces identical output run after run, with a race condition in linking finally cleared. The mesh emitter learned to read velocity, mass and custom attributes directly from the source object, falling back gracefully when those are missing. Constraints were polished so they break correctly before forces apply, and a performance pass freed extra wins on the underlying compute pipeline.

Pulled the standalone viewer into its own dedicated module so it can evolve independently from the main system. The interface was reorganised into a single cleaner panel, and several small visual glitches were ironed out along the way. Default values were also revisited to give a smoother first-run experience.

Worked on making the spatial neighbor search behave the same way every time it runs, so identical scenes give identical results. Tightened internal checks to catch any drift early and removed a small waste in the way data is held during the search. A timing issue that surfaced at higher frame rates was tracked down and resolved.

Minor maintenance work and refinements to the particle system following the recent solver stabilization. Small adjustments were made to ensure everything integrates cleanly after the recent major changes. The focus was on consolidating recent improvements rather than adding new features. The system is now in a clean state for the next phase of development.

After extended testing, the constraint solver has finally reached a stable state. The predictor component was disabled in favor of a simpler, more reliable V1 formula that produces consistent results. Several fixes were applied to clean up remaining edge cases. This marks a significant milestone in the physics simulation reliability.

Continued refining the constraint solver through iterative testing. Fixed several edge cases discovered during systematic test runs, pushing test coverage further toward a stable baseline. The iteration process helped identify and address subtle instabilities in the simulation. Overall solver robustness continues to improve.

Introduced a new coloring system for the particle simulation. Particles can now be assigned colors to better visualize their state, grouping, or behavior. This makes it much easier to follow individual elements within complex simulations. The visual clarity of the effect is significantly improved.

Worked on integrating molecular reference data into the particle system. This update brings the simulation closer to physically accurate behavior by grounding movement patterns in real molecular dynamics. The particle interactions now reference this data to guide their behavior more realistically.

This session focused on improving the stability of the particle constraint system. Pose-related workarounds were removed in favor of a cleaner, more direct approach. The constraint solver was simplified to make it more reliable and predictable. These changes lay the groundwork for a smoother and more consistent simulation experience.

Worked on planning and refining the collision detection system, improving how particles interact with solid surfaces. Focused on flat plane colliders and the underlying math for detecting surface contacts accurately. Added automated tests to validate the new collision behavior and catch regressions early.

Explored a new simulation scenario: a cloth draping over a sphere, showcasing how particle constraints can realistically model flexible fabric. This type of scene demonstrates the power of the constraint system for soft-body effects. Also set up a release notes template to make future version documentation faster and more consistent.

A new Constraint Preset node was added to the particle system, giving artists a convenient way to apply predefined constraint configurations without manually setting up every parameter. The node exposes a curated set of commonly-used constraint setups, making it faster to iterate on simulations with physical constraints. The existing constraint nodes were updated to integrate smoothly with the new preset system.

A bug causing infinite recursion in the constraint evaluation system was identified and resolved. The fix ensures the solver correctly exits evaluation loops without getting stuck, improving stability when using complex constraint chains. A minor additional fix was also applied for edge cases in the node system.

The GPU binding resolver was significantly streamlined, reducing its codebase by over a third while keeping all features intact. All simulation modules were updated to use StandardLayouts, making the binding system more consistent and maintainable across the board. Minor input handling fixes were applied to several nodes to improve reliability in the Blender interface. Documentation was also updated to reflect these structural changes.

A brand-new Event Spawner node was built from scratch, allowing particles to spawn new particles when specific conditions are met. The system runs entirely on the GPU through dedicated compute shaders for event detection and spawning. Collision-based spawning was added the same day, letting the simulation react to mesh or primitive hits in real time. Particle configuration properties were also extended with a new Particle Properties node for more granular per-emitter control.

The hook-solver branch was merged into the main codebase: springs and hook constraints are now fully integrated, tested, and working. All automated tests pass. A set of new example scenes was added — vertical chains, suspended tori, rigid cubes, large ground simulations — showcasing what the constraint system can do. Further determinism improvements were also applied, ensuring simulations produce identical results every run.

Pin constraints — which allow particles to be locked to a fixed point in space, like nailing one end of a chain to a wall — are now fully functional and validated by tests. This is a key building block for scenes like hanging ropes, suspended objects, and anchored structures.

Fixed an issue with how simulation results are transferred back from the graphics card to the CPU for inspection and validation. With that corrected, nearly all automated tests were passing again, bringing the codebase close to a fully stable state.

The motion integration system — the part that moves each particle forward in time — was significantly simplified and cleaned up, cutting the code roughly in half while making it easier to maintain. A small dedicated integrator was extracted as its own component, and all automated tests came back green, confirming the refactor did not break anything.

The spring and hook constraint formulas were reworked to match established molecular dynamics calculations, ensuring the simulation behaves in a physically accurate way. The older position-based solver was cleared out to make room for this cleaner approach, and the GPU constraint shader received a significant overhaul as a result.

Continued refining the test scenes for the constraint system — tweaking how suspended objects, stiff links, and large particle groups behave. Small adjustments were also made to how the GPU integration communicates results back, laying the groundwork for more accurate physics calculations in the following days.

Implemented a neighbor sorting system to ensure that simulations produce identical results every time they run. This is critical for reproducibility and debugging. Also diagnosed and resolved a conflict between the grab interaction and spring forces that was causing instability during user interaction.

Fixed issues in the fluid simulation, gravity, and vorticity systems. Enhanced the standalone viewer with better rendering capabilities. Created example scenes to demonstrate different constraint behaviors like ground contact, rigid body cubes, and stiffness comparison. Added extensive constraint validation tests.

Massive testing effort across the entire simulation engine. Added reliable tests for combustion, fluid dynamics, noise generation, reaction-diffusion, and vorticity. Improved the test framework itself to produce more consistent and meaningful validation results. Fixed several bugs discovered during testing across multiple simulation modules.

Investigated and documented a constraint collapse issue where particles would unexpectedly converge to a single point. Improved the GPU debugging tools to make it easier to diagnose simulation problems in real time.

Rewrote the core constraint solver with a new GPU pipeline architecture. This new approach splits the computation into prediction, conversion, and iteration stages for better stability and performance. Also cleaned up a significant amount of legacy code that was no longer needed.

Refined constraint grabbing, position-based dynamics, and visual relationship links. Improved debugging integration for constraint graph topology.

Replaced generic neighbor-search with domain-specific VOX (voxel-based spatial indexing) system with O(1) hash lookups and seamless collision integration.

Achieved 0.013ms filter execution by removing GPU-to-CPU mask transfer. Optimized particle-to-particle collision with spatial acceleration for millions of interactions per frame.

Completed central buffer management in gpu_device. Particles live exclusively in GPU VRAM with on-demand CPU access, achieving zero-copy architecture.

Merged Rust simulation engine into main project structure. Established workspace with neighbor-vox, bake, and gpu_particle crates for shared types and dependencies.

Migrated entire filtering system to GPU shaders in WGSL. Achieved sub-millisecond filter execution with zero CPU synchronization.

Eliminated all CPU particle data storage. Forced GPU-exclusive compute with CSR (Compressed Sparse Row) format for neighbor results. Major breaking change for massive performance gains.

Implemented CCD for high-speed particle impacts with real-world gravity validation. Solved the bullet-through-paper problem with swept collision detection.

Created headless sandbox framework with complete mock Blender API for testing without GUI, enabling fast iteration and CI/CD integration.

Migrated spatial queries to GPU using Z-Order (Morton) curves for neighbor finding. Designed transparent KDTree-compatible API for real-time multi-million particle simulation.

Introduced CustomAttributeNode allowing user-defined per-particle attributes and dynamic properties, integrated into baking and preview systems.

Extended object scanning to capture vertex colors and face corner data. Added random particle spawning from mesh vertices for refined emission patterns.

Implemented particle history tracking (tracer) for velocity-colored visualization and path animation support. Built for motion visualization and debugging.

Extended filter system to support multiple sequential filters on single node with unified interface, enabling complex particle transformations through stacked operations.

Overhauled emitter system with deterministic spawning and mesh deformation support. Introduced constraint node framework for verlet integration and particle linking.

Implemented SPH (Smoothed Particle Hydrodynamics) fluid system with Gaussian kernels, curl noise, turbulence, and vorticity for complete fluid simulation.

Enhanced simulation playback with frame-accurate scrubbing, object tracking in node trees, and improved cache management with performance profiling.

Added particle rotation tracking and morphing (shape interpolation) as first-class attributes, integrated into the node graph for advanced animation.

Refactored execution to single update loop with Arc/RwLock synchronization. Consolidated multi-threaded particle updates for improved stability and determinism.

Developed frame-based baking engine to pre-compute particle simulations. Added cache invalidation, UNDO/REDO support, and timeline scrubbing for Blender workflow.

Implemented Python FFI layer using PyO3 for Blender addon communication. Enabled bidirectional data exchange between Rust particle engine and Blender 3.x.

Built foundation for declarative, graph-based particle system workflows with nodes for emitters, forces, filters, and lifecycle management.

Implemented boid flocking behavior with collision avoidance and path following. Refactored force application to centralized queue pattern for extensibility.

Established foundational particle system architecture with basic physics, noise-driven movement, and Bevy GL visualization pipeline.