MayaFlux 0.5.0: The Substrate at Work

October 2026

Every piece shown on the home page was made with 0.5.

0.4 turned MayaFlux from a framework into a substrate: native platform backends, a standalone JIT, a GPU compute pipeline, a symmetric write layer. 0.5 is where that substrate is put to work. Roughly 920 commits separate the two, and four threads run through nearly all of them: simulation, IO, fluent authoring, and the numerical toolkit underneath.

Simulation is now a first-class domain. Fields written as ordinary C++ lambdas compile to compute shaders and drive particles, meshes, volumes and spatial agents. A GPU-resident spatial hash with claim, population and cluster dynamics, relaxation grids for cellular and diffusion systems, and a complete stable-fluids volume chain with a raymarcher all land together, and each is usable alone. IO no longer stops at the edge of the process: camera and video streams, GPU image capture, Alembic, OpenVDB, Assimp meshes, EXR, CSV and TSV all load and save through one IOManager and Depot, and live GPU state can be captured to disk as it runs. Authoring is the largest change of feel. Creator, config structs with designated initializers, generated overloads, vega.mint and vega.evolve turn multi-step sequences into single expressions. Kinesis grew into a broad numerical library, from filter design and polynomial kernels to estimation, motion channels and boolean logic, all dependency-free and reusable by nodes, buffers and controllers alike.

Computer vision runs end to end on the GPU, from a camera frame to contours, tracked keypoints and dense optical flow, and feeds back into rendering and sound through the same buffers and containers as everything else. Interactive surfaces gain scrolling, editable text and window lifecycle handling, and a tap-based sampler and a texture-array compositor round out the release.

Platform

macOS: a native Cocoa window backend (CocoaWindow, an NSWindow with a CAMetalLayer content view) is now the windowing backend, with key repeat generated from KeyRepeatConfig to match Wayland and Win32. GLFW is removed on every platform, including the build, packaging and CI scripts. macOS support targets Apple Silicon with Clang 17 or newer, std::format replaces fmt, and the native libc++ parallel algorithms replace oneDPL.

Windowing: text input events (WindowEventType::TEXT_INPUT) arrive on Wayland, Win32 and Cocoa with their own repeat timing. Interactive resize signals once per completed gesture on Wayland and Win32. Closing a window propagates through Kriya and Forma, cancels its handlers, and detaches its render processors while the buffers survive. The Wayland backend now reads its display socket in poll() rather than depending on the WSI to do it.

Graphics devices: GPU selection is configurable through GraphicsBackendInfo (device_index, device_uuid, device_name, device_preference, require_presentation, strict_device_selection), with presentation families resolved at device selection. User supplied device extensions are validated before createDevice, with every missing name reported.

Input: a cross-platform tablet backend over HIDAPI with a HID 1.11 report descriptor parser delivers a 12 slot frame (position, pressure, tilt, rotation and more) with no window required. TabletNode projects one slot as a smoothed scalar while carrying the whole sample into every callback through TabletContext.

MIDI: the PipeWire backend gains an ALSA sequencer virtual input port that other applications can subscribe to.

Build: shaderc and SPIRV-Tools are required dependencies, Alembic is added for spatial IO, and mold is used on Linux when installed. MAYAFLUX_ENABLE_LTO is controlled through presets and enabled for every shipping preset. unix-dev is a RelWithDebInfo preset and unix-test covers Debug testing. GLSL source installs to share/MayaFlux/src/shaders beside SPIR-V under runtime/shaders, and the user guides install to share/MayaFlux/guides. Config::set_project_root resolves data, output and logs against a project’s own root, and a report configuration (data/report/mayaflux.report.json) turns on validation layers and a trace log for bug reports.

Vision

Vision is a full GPU-resident analysis stack described in docs/Vision.md. Operations are declared as a VisionSequence through a fluent builder that takes parameter structs and designated initializers, and run by VisionGpuExecutor (GPU, the default) or VisionExecutor (CPU, selected through VisionBackend). Both share one op signature through VisionPass.

Operations: global, adaptive and Otsu thresholds (multichannel, so a hue range and a saturation floor compose), colour conversion, Gaussian and arbitrary separable filters, Sobel and Scharr with gradient angle, Canny, morphology including Open and Close, Harris response with region masks, peak extraction, connected components, contour tracing, sparse Lucas-Kanade tracking with a forward-backward check, dense optical flow over a pyramid, Downsample2x, Confine for region restricted pipelines, and Snapshot. The CPU path carries AVX2/FMA and NEON SIMD in the filter, pixel, Harris and downsample kernels.

GPU execution: sequences dispatch as dependency stages with explicit hazards, so Otsu, Open and Close, connected components and contours each cost one submission and one fence wait. Descriptor writes are batched per dispatch, intermediate images are reused through TextureLoom, and flow and label buffers live in device-local memory. Connected components use block-based labelling with GPU-resident compaction. Contour selection is a K-round top-K reduction. Steps marked deferred submit asynchronously and resume on a later call, and results report is_ready(). An op-result memo keyed by hash_vision_step shares identical Sobel and blur work inside a walk. Tracked keypoints export to device-resident buffers without a host round trip. A vision_ingest.comp prelude converts the seed frame to rgba32f storage so the pipeline runs on both RADV and the NVIDIA proprietary driver.

Query layer: VisionQuery names what an analysis should produce through composable VisionIntent flags (FindElements, TrackObjects, DetectFeatures, DetectEdges, EstimateMotion, MeasureAppearance) with per-intent parameter structs, including colour segmentation and region confinement. Resolution shares leading GPU work across intents. VisionAnalyzer is a Yantra analyzer that reduces results on the GPU into centroids, bounds, shape statistics, appearance histograms and motion energy, runs each lane on its own executor, and can advance one sequence per call. VisionExtractor is a Yantra operation that turns an analysis into pixels: crops, sample_regions, silhouettes, select_element, mask and patches. VisionMatrix owns an analyzer and extractor for a query, keeps the last frame, analysis, extraction and per-lane results, and exposes result(VisionIntent).

Workflows: VisionWorkflow (from create_vision_workflow) runs a query live on any VideoStreamContainer, cameras, video files and dynamic streams alike, delivering extractions into a second buffer (WorkflowBufferConfig), a live TextureCollection (WorkflowContainerConfig), or the layers of a Chimera (process_to_stream). frame_results broadcasts per-frame results through a BroadcastSource, and subscribe attaches coroutine consumers to any source. ImageCVProcessor and VisionProcessor run sequences directly on GPU images and pixel containers. The workflow holds the engine’s managers weakly and stops its runs when destroyed.

Shader generation and fields

ShaderSpec: ShaderSpec::Assemble describes a compute kernel declaratively (SSBO, sampled and storage image bindings, push constant fields, a KernelTemplate and typed KernelOps) and ShaderFoundry::load_shader emits SPIR-V assembly directly, caching by content hash with no GLSL toolchain involved. KernelOp covers the arithmetic set, the GLSL.std.450 math set, CompareGE, ChannelDot and reductions, and Convolve2D is a kernel template. MF_KERNEL captures a lambda body as source for kernels that need conditionals or loops, and standalone functions can precede main. Generated kernels bind into any executor through config_from_spec and bindings_from_spec, and into RuleBuilder through with_gpu_backend.

Fields: MF_FIELD stringifies a lambda and compiles it twice, once for the host as a Tendency and once as a GLSL function through FieldSource, so the two halves come from the same characters and cannot drift (DualField). MF_FIELD_T builds a TemporalField of position and time, and MF_FIELD_P a ParametricField that also receives a vec4 parameter block. FieldTarget is an open bitmask, so one bind can drive position and normal together. MF_BITMASK_OPERATORS generates the operators for any scoped enum. GpuFieldOperator declares field deformation as a generated compute pass, VertexFieldProcessor dispatches it over a vertex range, and ComputeMeshBuffer accepts fields on either backend. The SDF include library gains line, plane, anisotropic Lp ball, triply periodic surface and metaball kernel families plus rotate, mirror, repeat, radial repeat and twist operators.

Per-cycle feeds: ShaderProcessor inputs can be supplied by a callable pulled every cycle, landing in the push constant block or a storage descriptor, and the feed now lands after a processor’s own push constant write.

Simulation

Simulation in 0.5 is built from small GPU-resident parts that share one vocabulary: fields, lattices, processors and config structs. The same field expression can deform a mesh, push particles, seed a volume or place a spatial agent.

Particles and spatial hashing: SpatialFieldConfig on GpuFieldOperator builds a GPU-resident counting-sort spatial hash over any network’s vertices (HashClearProcessor, HashCountProcessor, HashScanProcessor, HashScatterProcessor) with density colouring and a deterministic pairwise claim protocol for absorption (atomicMin over the 27 cell neighbourhood). Persistent accreted mass is tracked in PhysicsOperator. Population dynamics run entirely on the GPU over an over-allocated reserve region: destroy on absorption, spawn on crowding. Cluster ids derive from PhysicsOperator::get_collections(), field bindings can be cluster scoped, and with transfer_on_claim a cross-cluster claim hops a vertex between clusters instead of consuming it. The pipeline reaches PointCloudNetwork and any GraphicsOperator, NetworkGeometryBuffer declares named auxiliary state fields alongside its vertices, and live setters tune thresholds and growth while it runs. Proximity graphs are parallelised and incremental geometry upload skips whole-buffer re-aggregation.

Relaxation grids: RelaxationGridBuffer is a GPU-resident double-buffered grid for any synchronous local rule (cellular automata, relaxation, diffusion, reaction systems), configured through GridConfig with a stage per compute pass and a single generation owner. Its state can be snapshotted, captured to disk through RelaxationGridCapture, and emitted as geometry through a rule and emit contract.

Fluids and volumes: VolumeGridBuffer holds named fields on a Lattice3D and ships the stable-fluids chain as processors on a shared VolumeFieldProcessor: AdvectProcessor, DivergenceProcessor, PressureProcessor, SolenoidalProcessor, DiffuseProcessor (implicit backward Euler by Jacobi), BuoyancyProcessor, WallProcessor and InfluxProcessor. Typed field refs from declare_scalar, declare_vector and declare_scratch remove string repetition, setup_flow builds the incompressible stage set from a config, and accumulate and influx inject authored fields. RaymarchBuffer and RaymarchProcessor render a scalar field front to back with early termination over a proxy box, configured through MarchConfig, and isosurfaces extract on the GPU through ComputeMeshBuffer.

Lattices and assemblies: Lattice1D, Lattice2D and Lattice3D in Kinesis pair resolution with bounds and derive cell geometry once for every consumer. AssemblyNetwork holds an unordered set of independent geometry items, each added, removed or updated on its own, under one milled draw. RelationNetwork hosts a growable set of slots and operators (see Kinesis and controllers). generate_explicit_surface builds a mesh from a table of heights, for blocks of sound, image brightness or spectrogram columns, and curve evaluation (MotionCurves) runs on a planar SIMD core and emits tangents alongside positions.

Camera, video and Chimera

Cameras are enumerated through libavdevice (v4l2 and dshow) with preset capture modes and a fallback open path, behind a pluggable CameraSource. Depot::choose_camera lists devices and modes in a Forma picker, choose_video returns the video and audio pair with VideoReadOptions::EXTRACT_AUDIO, and Creator::read_camera and read_volume join the loader family. container | Graphics hooks any VideoStreamContainer and returns it typed, audio included. get_associated_buffer finds what a container was hooked to. Containers are format aware: depth modalities (DEPTH_MAP, VIDEO_DEPTH), ValueRange, and the requested pixel format carry through the FFmpeg read path.

TextureArrayBuffer is a texture buffer whose image is a stack of layers, bound as sampler2DArray. Chimera assembles those layers from many sources: stills and files, GPU images copied every frame, and moments of a recording ring or a growable GPU-held TextureCollection, read at a lag, at a lag that follows a TimeMap, or played freely forward, held or backward. SamplerForge::plan_fit handles stretch, contain, cover, center and tile placement, and the blit and per-layer upload paths avoid host downloads. BufferPipeline now runs at frame rate and takes graphics sources and targets, with capture_to_stream, end() for cancellation and render configuration on any operation.

Sampling and time

TimeMap is a tendency from seconds on a local clock to a position in recorded material, with linear, quadratic, triangle, piecewise_linear, lagged and integrated factories. StreamSlice::time_map replaces speed with a map evaluated per block and read with linear interpolation, giving scrub, reverse, acceleration and ping-pong, and StreamSlice::repeat restarts the map at a changing repeat length. TapSet plays several independent taps on one stream, each with its own entry time, speed, direction, level and channel, with live speed control and lookback taps that trail the write head of a circular stream (create_ring, TapSetBuilder::lag). DynamicSoundStream rings are writable from BufferPipeline and can snapshot the most recent frames into an independent stream. Channel mix normalisation is switchable, and record_into accepts buffers and several sources at once.

Kriya pattern now takes durations as a list, a function of the pass number, or a condition, with typed generators and callbacks and no std::any. Routine::on_complete fires once at final suspend or on cancellation for every routine kind, and EventChain completion is built on it. SweepList and AsyncGroup provide lock-free async task tracking used by IOManager and ComputeMatrix.

Kinesis and controllers

Kinesis is the numerical layer, free of node, buffer and Vulkan types, and 0.5 expands it across every domain it serves.

Filter and kernel design: Discrete::Coefficients provides the eight RBJ biquads, windowed-sinc FIR (lowpass, highpass, bandpass), direct pole placement, biquads by value for live rewriting, and ring-time math with no Q ceiling. Kernels adds polynomial_lags, fourier_series, breakpoint_curve, pattern_lookup, dilate, erode, quantile, zscore, goertzel and modular_recurrence, plus state-bearing kuramoto and coupled systems, all convertible to node buffer functions. Dynamics adds pulse_response and lotka_volterra_step, and window helpers gain boxcar support regions and exponential ramps. Lagrange weights are divide-free.

Boolean logic: Discrete::Boolean provides bit-valued kernels that keep their memory in the coefficient array (truth_table, set_reset_latch, comparator with a dead band, window_comparator, signals_at_least, input_truth_table, clocked_register), so behaviour is the numbers and survives clone, save, restore and live retuning.

Coefficient-driven nodes: Polynomial, Logic and DeriveOperator accept functions that receive the node’s own coefficient array and keep state in it. Logic reads slots from other nodes, and LogicProcessor gains keys that read other buffers as input slots, bit planes that run every bit through its own clone of the node, and a neighbourhood automaton with memory across blocks. FeedbackProcessor is rebuilt around taps and combiner lambdas with linear or Lagrange reads up to order 7, and BlockFeedbackProcessor joins it. ResonatorNetwork retunes and sets decay in place, so a mapped parameter keeps its ring. edit_feedback_coefs and edit_feedforward_coefs give filters allocation-free spans, and IIR and FIR cache post-gain output per channel and normalise a[0] at the setter.

Estimation and motion channels: Stochastic::Estimate tracks the statistical character of an arriving stream (rolling variance, median absolute deviation, exponentially weighted variance and more), the analytical counterpart to Stochastic. Differential provides finite differences through named kinematic orders, central variants, curvature, heading and angular delta, and windowed path measures (length, displacement, straightness, turning, centroid, spread). HampelFilter screens isolated spikes, and MotionChannel wires Estimate, Differential and HampelFilter per stream, with per-order filtering and self-calibrating curvature. SymbolicTrajectory tracks cell sequences of a moving point through a Lattice1D, Lattice2D or Lattice3D partition, so a stroke, a gesture or a scalar stream becomes a symbolic sequence. FeatureExtent supplies fitted box and ellipsoid extents with graded membership and ThresholdLatch hysteresis, and PathShape supplies shape descriptors. Together with TabletNode, InputNode callbacks and Perception, these are the controller building blocks: a denoised, differentiated, classified view of any incoming stream.

Relations and routing: RelationNetwork is a dynamically growable slot-and-operator host with AdvanceOperator, CombineOperator and WalkOperator. Weights is a lock-free stochastic transition and routing table with weighted_pick, and WalkOperator moves a single active slot along its rows. Covariation.hpp provides multi-stream correlation and coherence measures.

Nexus

Agent::attach, Emitter::attach and Attachment place an existing buffer on a principal, anchored on the surface centroid or a chosen vertex, with the offset expressed in the Agent’s frame. Placement works through a geometry transform published alongside view and projection in the render UBO (Kinesis::RenderTransform), applied by the point, line, triangle, mesh, milled and volume shaders, and GPU fields evaluate through it. Influence<T> and Perception<T> let a producer or source build a value of any type from the context and hand it to targets; header-only field targets (bind_field, bind_force, bind_position, bind_transform, bind_params, bind_push_constants, bind_influence_block) feed fields, operators and shaders. Lights are an InfluenceBlock delivered through push constants. Agent, Emitter and Sensor no longer need functions when typed influences and perceptions supply their behaviour.

Expanse gains AABB3D bounds and typed crossing actions, Hull takes its region from a buffer’s bounds and follows the buffer wherever it is placed, Mantle places a buffer to fill a box under FitMode, and an Expanse can perceive its occupants. State encoding and decoding (schema 6) cover the current classes.

Portal

Forma: Scrollable (CPU scroll state, optional per-buffer scissor clipping, draggable indicator), an editable TextField with caret, up/down movement, click and wheel hit testing, Tend<T>, Collapsible labels composed with a background, Portal::Forma::pick for a generic list chooser, Context::to_ndc_rect for pixel-exact placement, and bring_to_front and send_to_back through draw_priority. Factories return Form<T> carrying topology, capacity and wiring, and Surface construction is unified through SurfaceConfig. Layer::remove cascades through relate() closures, and aggregated mapped ranges write into processors through Bridge.

Text: UTF-8 stepping and control-codepoint handling with tab stops and kerning, byte offsets and per-range style spans in layout and ink, x_at and index_at hit testing, range extraction with layout quads, EditableText operations, and a solid background composited under live text.

Graphics: PrimitiveMill reduces mixed-topology spans to triangles (points to quads, segments to mitred ribbons) so a buffer opts in through RenderConfig::triangulate, and also replaces the CPU line expansion on macOS. ComputePress::record_sequence records several compute pipelines in one submission, and TextureLoom reuses images across dispatches.

IO

MayaFlux is no longer an island. Everything the engine produces or consumes can cross the process boundary, live or offline, through IOManager, with Depot adding native dialog-backed variants of every loader and saver. Each write path is asynchronous, tracked through AsyncGroup, and flushed on shutdown.

Streams and capture: cameras (v4l2 and dshow through libavdevice, behind a pluggable CameraSource), video files with their audio track, window and swapchain capture, GPU image readback (TextureLoom::download_image returns typed ImageData), and per-frame host snapshots of buffers, geometry and images through DataReadProcessor. DataWriteProcessor gains write_* routes for fields, slots, meshes and pixels in the other direction.

Geometry and volumes: ModelWriter exports meshes through Assimp from MeshBuffer, MeshNetwork and GPU-extracted ComputeMeshBuffer isosurfaces. VolumeReader, VDBWriter and VolumeCapture import and export OpenVDB grids, numbered sequences included, with LatticeSemantics stored as grid metadata. SpatialCache and SpatialReader write and read time-sampled points, curves and per-vertex attributes as Alembic, with capture_spatial recording one or more network geometry buffers, particles and point clouds included, frame by frame onto a shared clock, and RelaxationGridCapture recording the cell state of a relaxation grid. Image writers cover PNG, JPG, BMP, TGA, HDR and full-precision EXR.

Tabular and structured data: Composite, CompositeLayout and CompositeContainer hold heterogeneous named records (arithmetic, UTF-8 text, dynamic NULL/INTEGER/REAL/TEXT/BLOB values, fixed BLOBs). DelimitedTextReader and DelimitedTextWriter load and save CSV and TSV through IOManager, Depot::choose_composite and vega.read_file. DataFieldTraversal gives windowed access over any element type, and Yantra admits composites as ComputeData.

Layout: IO/ is reorganised into subfolders by backend coupling, IOManager mechanics live in IO::Detail, writer registries share one WriterRegistry<Writer> template, and bare filenames write to data/out and data/log.

Fluent authoring

The biggest change of feel in 0.5 is how little code a complete idea needs.

• Creator factory overloads are generated from constructors through Clang’s AST, so the language server shows real parameter lists and defaults instead of forwarding templates. New members cover create_chimera, create_texture_array, create_vision_workflow, create_ring, create_sampler, create_samplers and create_tap_set, plus read_camera, read_volume and read_file.
• vega.mint takes a StructureConfig and builds a whole visible structure: it resolves the source, builds any network, registers in the required order, attaches textures and configures rendering, returning the real buffer. Model components can parent under earlier components or network slots.
• vega.evolve takes a config and wires state that advances on its own each cycle, starting with RelaxationGridBuffer.
• Config structs everywhere: GridConfig, MarchConfig, Spot, SurfaceConfig, WorkflowBufferConfig, WorkflowContainerConfig, ComputeMeshBuffer::Config, AttachConfig and the vision parameter structs take designated initializers. EnergyAnalyzer, StatisticalAnalyzer, FeatureExtractor, StandardSorter and the transformers gain aggregate configuration constructors.
• Pipes and chains: container | Graphics hooks a video or camera container in one expression. Fluent Scrollable placement, ChimeraBuilder, TapSetBuilder, VisionSequence::Builder and Forma factories that return Form<T> keep multi-step setup in one expression.
• Typed scheduling: schedule_pattern forwards to the typed Kriya::pattern forms, and schedule_task returns a shared_ptr.
• Lambdas to kernels: MF_KERNEL, MF_FIELD, MF_FIELD_T and MF_FIELD_P turn an ordinary C++ lambda into a compute kernel without leaving C++.
• Includes: MayaFlux.hpp includes Convenience.hpp unless MAYAFLUX_NO_CONVENIENCE is defined, workflow groups are opt-out, and filter coefficients and Nexus field targets are visible to user code by default.
• Diagnostics: journal output can be filtered by component and context, and Config::set_project_root anchors data and logs to a project.

Concurrency

Every Kakshya container (SoundStreamContainer, TextureContainer, WindowContainer, VideoStreamContainer, PlotContainer) now synchronises with purpose-scoped Seqlocks and SeqlockArrays, so readers never take a mutex. NDDataContainer<T> is templated on its element type, and frame and value access are typed through FrameView and DataSpanVariant instead of widening to double.

Upgrading from 0.4

• GLFW is removed. Native windowing is used on every platform, and WindowingBackend::GLFW and GLFW_BACKEND are gone. Intel macOS is no longer supported.
• API/Yantra is removed. Use Yantra operations and Kinesis algorithms directly.
• IO::LoadConfig is IO::VideoLoadConfig, and load_video and choose_video return std::pair<video, audio>.
• ComputeMeshBuffer is constructed from ComputeMeshBuffer::Config only. The two positional constructors are removed.
• Mock processing is Node::exclude_output_from_graph.
• MAYASIMPLE and the MAYAFLUX_ALL_* gate macros are replaced by explicit includes, Convenience.hpp and opt-out groups.
• Lit fragment shaders read the Influence block from push constants rather than a set 1 uniform buffer.
• get_frame and value_at on containers are typed through FrameView and get_value_at<T>. The container lock, unlock and try_lock triad is removed.
• MAYAFLUX_USE_SHADERC, MAYAFLUX_USE_FMT and MAYAFLUX_USE_JTHREAD are removed. Execution.hpp is removed in favour of std::execution.
• WindowGenerator, CycleCoordinator, VKRenderPass and VKFramebuffer are removed.

Source: github.com/MayaFlux/MayaFlux Docs: mayaflux.org License: GPLv3

Commit Summary

See full diff: Github

83b8c2784 prepare for 0.5 release
74de4cd9a fix(config): export project root accessors from the DLL
b96b0946a chore(export): Final dllexport check before release
fd960bc43 feat(vulkan): warn when a render pipeline lacks a binding its shader uses
7c1167939 chore(README): Link tingling time example from community projects
dd25473b9 fix(input): open HID devices non-exclusively on macOS
d5a3fcbc3 test(api): cover default engine lifecycle and the End getter deadlock
218ad5f7c fix(api): publish the default engine lock-free so End cannot deadlock getters
6d69231ca fix(io): split IOManager shutdown into stop and shutdown
76d38191a fix(input): log HIDAPI errors in tablet backend and decode HID strings as UTF-8
a5747380a chore(vruta): log scheduler shutdown completion at info level
33ae6e887 fix(buffers): clear device-local VKBuffer on the GPU
4608e810f Add community links to examples
fc4bffecb Add topsoil example to README.md
07058422c test(io): cover ImageReader crops and channel conversion
bf8e950fa fix(buffers): display R8 and RG8 textures as grayscale
933b6cfab feat(io): support pixel regions and channel counts in image loading
8feb1f41e chore(README): Add more examples
bb607e0c6 fix(render): draw each run separately when several share the pipeline topology
ba10e5e23 fix: correct DLL exports across MayaFlux public interfaces
64e135f6e fix(vulkan): release raw generation slots when the resource manager shuts down
aa584b421 fix(vulkan): stop destroying borrowed index handles in buffer cleanup
b502bf73c fix(shaders): use SPIR-V paths for supplied shaders
edb0d61d8 docs(README): Add attrition example
be418b2b7 feat(kriya): expose the sampling pipeline behind a tap
ffca6bbdf docs(release): add 0.5.0 release notes body
9a43d6195 docs: merge ethical declarations into code of conduct, drop BuildOps
22097fe38 docs(Getting Started): Add video example
cdc1eabed docs(getting-started): present the first program as something to play with
d95c9378c feat(buffers): evaluate MF_FIELD fields on the GPU in ComputeMeshBuffer
45c58ab64 feat(shaders): generalise the SDF include with families and operators
fb4705683 refactor(buffers): construct ComputeMeshBuffer from its Config only
ef6be415d docs: New shorter readme
143615453 docs(startup): fix the startup order and Viewport upload, add diagrams
c3fe9985e docs(yantra): add diagrams across the Yantra guides
f4cc594ea docs(yantra): add diagrams to the compute guide
934177e63 docs(architecture): add diagrams to the Digital Architecture overview
2ee0c1d25 docs(nodes): add Relations guide with starter tutorial and five compositions
78eb68afc fix(macos): missing stdlib headers
ed0ff6f26 refactor(api): take attach_quick_process channels as a braced list
e0d2c91cf feat(nodes): coefficient arrays and gate rules for DeriveOperator
14106c374 fix(nodes): apply ModalNetwork's decay multiplier to the modes
2fcd94ea3 refactor(nodes): give RelationNetwork operators shared ownership at their boundaries
4dc744857 docs(getting-started): make the first program a room of voices on a Nexus Fabric
2c60d4ae5 feat(includes): expose filter coefficients and Nexus field targets to user code
a45a04bdb docs(getting-started): replace the first program with a coupled audio and GPU scene
adea528f1 feat(buffers): let a push constant feed land after the processor's own write
128a221af docs(issues): streamline Weave project bug reporting
e8b83bff5 Expose FFmpeg Shared headers and libraries in Windows setup
497d9f6cf feat(config): resolve project paths against a settable project root
73252f86b ci(docs): extract the doxygen build into a reusable workflow
3a8194b5f build(ubuntu): drop the doxygen documentation package
92c249a83 build(packaging): sync stable Fedora and Ubuntu packaging with dev for 0.5.0
94bc2efa9 docs(dev-getting-started): sync build presets, dependencies and OS floors with 0.5
d3a40bac2 Fix Windows SPIRV-Tools discovery in exported CMake config
d0cd84789 feat(install): ship user guides to share/MayaFlux/guides
2612914ae docs(vision): add a guide to live vision analysis and its images
8322ffd81 docs(compute): refresh the CPU-GPU IO map and OpenCL migration guide for 0.5
194c42fb0 fix(shaders): search user shader directories before library output
651ca8dbd feat(install): ship GLSL shader source and move SPIR-V under runtime
452aa62ed docs(templates): refresh user_project template for current config surface
90ff63721 fix(windows): normalize FFmpeg Shared installation paths
833ba5658 docs(architecture): refresh Digital Architecture overview
39ed33fd1 test(portal): cover PrimitiveMill, mill_on_host and VertexLayoutTranslator
42586a8d7 fix(portal): mill_on_host marks point corner UVs like the kernel
50eaaee73 test(portal): cover ComputePress pipelines, dispatch and push constants
67aa370b0 fix(portal): ComputePress initialization order and guards, add partial push constants
93b7cdacf test(portal): cover RenderFlow and fix two lifecycle defects it exposed
e0044ed05 fix(portal): clean every ShaderFoundry module on shutdown
7689f84f6 build(cmake): control LTO through presets and CI
6011837cb fix(portal): RenderFlow::destroy_pipeline destroyed the pipeline layout twice
c3958f803 refactor(vulkan): remove the unused VKRenderPass
4d10bb1ad test(portal): cover ShaderFoundry compilation, registry and command paths
116b42050 test(portal): cover TextureLoom and the image format mappings
57ea41dff test(portal): cover SamplerForge caching and plan_fit
a7cc1ed44 test(portal): cover ShaderSpec, KernelSource and the shader emitters
d2e917de0 test(core): rewrite SubsystemManager tests against fake subsystems
ea5dffff9 fix(platform): trim Windows macro undefs to what each file needs
0cb81bd56 fix(core): export Vulkan helpers and shared dispatcher on Windows
44788db31 fix(graphics): keep captured frames intact for observers on macOS
9037642fe test(graphics): service the main queue while windowed subsystem tests wait
4f28f653d fix(graphics): carry the dispatcher through VKInstance moves and re-adopt windows after a restart
164b50061 fix(graphics): prevent window handler hang and crashes, and cover BackendWindowHandler
c1d9a1eb1 test(window): share the Wayland compositor probe and environment helpers
2f7fb92a8 fix(graphics): keep the shader attached to a compute pipeline and cover both pipeline types
e1c96476f fix(graphics): repair descriptor batch, specialization, image cleanup and backend restart
41b3b491a test(graphics): cover Vulkan backend lifecycle and CPU side value types
c2988a486 fix(graphics): guard null backend in GraphicsSubsystem and cover its lifecycle
c41b05bb2 fix(graphics): release context on failed init, reject failed shader and pipeline creation
6da56bdb5 test(system): cover DBusBackend against a private bus and mock portal
09b273f29 fix(system): make DBusBackend portal requests spec compliant and non-spinning
062839b28 test(nodes): cover InputNode extraction, smoothing and callbacks
7fa5bca72 test(network): cover UDPBackend, TCPBackend and NetworkSubsystem
c57e13f5d test(input): cover InputManager and InputSubsystem
77e626da8 test(input): cover HIDBackend lifecycle, enumeration, filters and device opening
3b0953d19 fix(input): announce each HID path once per enumeration pass
fe82dd432 test(input): cover TabletBackend descriptor parsing and lifecycle
08aaed811 fix(input): reactivate a closed tablet tool in TabletBackend::open_device
d3ef157a0 test(windowing): cover WindowManager registration, destruction and processing
545e13e29 fix(windowing): discard windows without a native handle in WindowManager
739089b24 test(wayland): cover WaylandWindow lifecycle and key mapping
e380da085 fix(windowing): skip pending configure in WaylandWindow::poll after destroy
64c9759a9 test(core): rewrite AudioSubsystem tests around coordination and lifecycle
0190f1802 fix(audio): join notify thread in AudioSubsystem::shutdown
d172535c0 test(macos): cover NSBackend file dialog lifecycle and cancellation
a585cc97a test(macos): cover Cocoa window backend
ade59504b test(windows): cover COMBackend file dialog lifecycle and cancellation
0893e1432 test(windows): cover Win32 window backend
c83a13326 test(windows): cover WASAPI and WinMM MIDI backends
03aea8255 fix(windows): resolve MSVC compilation and test linking failures
6e341ffe7 test(midi): cover CoreMIDI virtual destination lifecycle
8a0cb59de feat(midi): add ALSA seq virtual input port to PipeWire MIDI backend
e143f5527 test(midi): cover CoreMIDI lifecycle and message delivery
f5fa5ff49 test(audio): cover CoreAudio backend lifecycle and callbacks
6086e22f6 fix(audio): balance PipeWire lifecycle and test backend
3dc934dd8 test(core): expand engine lifecycle and backend integration coverage
9c4fac2f8 test(events):  add Event, EventManager and event source suites
b604538ee Docs: note Event::on_complete limits and record Events status
4b2fc0a88 Vruta: harden EventManager teardown and add Event::on_complete
f4468ac4c chore(reorder): Move scheduler_test.cpp to tasks folder
34fdd4b3c refactor(kriya): move EventChain completion onto Routine on_complete
4582cf327 fix(vruta): make TaskScheduler::terminate_all_tasks a safe submission barrier
a449243c3 feat(vruta): add once-only completion callbacks to Routine
c3a09f937 feat(api): typed schedule_pattern and a shared_ptr schedule_task
cd8b691ac feat(kriya): duration forms for pattern, replacing the single interval
4d8ef9259 test(vruta): rewrite scheduler tests around deferred queues
beb3f08b7 fix(vruta): cancel sound, graphics and cross tasks by name
10d258a08 test(kriya): rewrite task tests as parametrized suites
1d08b62c7 fix(kriya): honour fractional durations in line()
5311e982c fix(vruta): cancel a routine whose add is still pending
71e7e2554 feat(kriya): condition driven pattern in Pattern.hpp
9312476f3 deprecate(kriya): mark Gate, Trigger and Toggle for removal
a7a9254cd test(buffers): cover LogicProcessor keys, bit planes and the neighbourhood automaton
303902133 feat(buffers): keys, bit planes and a neighbourhood automaton for LogicProcessor Adds three optional ways to drive a Logic node from a buffer. add_key reads other buffers as extra input slots of a parallel node. set_bit_planes splits samples into offset binary words and runs every bit through its own clone of the node, which with keys gives bitwise word operations across channels. set_neighbourhood treats the block as cells of an automaton evaluated over each cell's neighbours, with optional memory across blocks. The default per-sample behaviour is unchanged.
f05cdb273 test(nodes): cover multi input hooks, context coefficients and default function clones
8b57379e1 fix(nodes): fire Logic hooks from process_multi_input and keep clones independent process_multi_input now notifies before updating the last output, so change, true and false hooks fire. The built in parallel function is rebuilt per node instead of capturing the original in clone(). LogicContext gains get_coefficients().
b66a453e1 feat(nodes): input nodes and coefficient arrays for parallel Logic Logic in parallel input mode can now read its slots from other nodes. add_input_node and set_input_nodes fill slots 0 to n-1 in order and grow the slot count to fit; when more slots are declared than nodes, the next slot receives the sample the node is driven with, and with no nodes that sample still goes to slot 0. Nodes are pulled with the same modulator count and processed-flag handling as the single input node, saved and restored with the node, listed by get_modulators and shared by clone().
d7525ef93 feat(kinesis): parallel boolean kernels for signal against signal logic Adds the parallel shape to Discrete/Boolean: set_reset_latch, comparator with a dead band, window_comparator, signals_at_least, input_truth_table and clocked_register, each keeping its state in the coefficient array and returning false for an array too short for its layout.
99f150559 perf(kinesis): divide-free Lagrange weights and vectorisable reductions in the polynomial kernels
33fe4bc17 feat(kinesis): boolean kernels with state in the coefficient array
d361f2532 test(nodes): parameterise the Logic and LogicProcessor suites, cover coefficients and clone
53ffc74bf feat(nodes): coefficient functions and clone for Logic, clone for LogicProcessor
379159937 test(nodes): add a disabled resonator load benchmark; correct two comments
badbc8efd feat(buffers): Lagrange reads, kernel combiners and a lag source for FeedbackProcessor, and BlockFeedbackProcessor
2e477fd59 feat(nodes): in-place mapping, array setters and buffer reuse for ResonatorNetwork
46211957c feat(kinesis): array dynamics, sequences, rotor bank and tabulate
e5584b311 test(nodes): reorganise and slim the Polynomial and PolynomialProcessor tests
15f53d7a8 feat(kinesis): polynomial kernels, shared table lookup, decay_per_sample and Polynomial clone
19c49ed2c feat(kinesis): biquad by value, decay math, window weights, soft clip and polynomial kernels
0542e5b33 feat(kinesis): scalar window measures, 1D bounds and lattice, non-allocating span differences
8be1c33f0 feat(buffers): rewrite FeedbackProcessor around taps and combiner lambdas
b02ebc23c feat(nodes): in-place retune and direct decay for ResonatorNetwork
5f7ddfdc2 feat(nodes): coefficient-array buffer functions for Polynomial
19931ee64 fix(yantra): make VisionAnalyzer non-copyable for MSVC
5f60ff973 feat(yantra): vision workflow gaps pass
72a1e0f28 feat(yantra): lane results by intent, owned results and analysis rate for streams
e3c089e48 feat(yantra): record vision images into collections in process_to_stream
d0e862f87 feat(kriya): feed Chimera layers from a TextureCollection
d9fb77786 feat(yantra): add VisionWorkflow::process_to_stream, first pass
c6870b371 feat(yantra): keep VisionMatrix extractions and read its operations from the pool
e5d2f87ac fix(yantra): start every vision run on the same pixel image
6f715e446 feat(yantra): keep the last analysis' lane results on VisionMatrix
01ca2f96a refactor(yantra): rename LiveConfig::extract_from to apply_to
88efb06ac feat(api): expose VisionWorkflow through create_vision_workflow
8b9d63474 feat(yantra): configure VisionWorkflow live runs with config structs
0513a3101 feat(yantra): run VisionWorkflow on any video stream and extract from a second buffer
a5dd17421 feat(kriya): signal frame_results into an existing BroadcastSource
9366377eb feat(yantra): add VisionWorkflow
16ffcc33c feat(yantra): keep the last frame and analysis on VisionMatrix
58e0582cb feat(yantra): add VisionMatrix
4d8504e69 feat(kakshya): bound TextureCollection growth with a spec and ring mode
f7550063b feat(kriya): name the frame_results task
a36c91b71 feat(kakshya): add TextureCollection, a growable GPU-held TextureContainer
5409152a3 feat(yantra): extract from a GPU image supplied in Datum metadata
a106cbf08 feat(kriya): add subscribe for broadcast sources
76958dae0 feat(kriya): add frame_results broadcast source
59156fc50 feat(yantra): step VisionAnalyzer through its sequences one per call
4298c6b72 fix(kinesis): give CannyParams default values
2bd27696e feat(yantra): chain FunctionalOperation children as annotations
c0914a69a feat(yantra): run each vision lane on its own executor
4d5f99813 feat(yantra): implement Snapshot on the GPU vision executor
a37317cdc  fix(yantra): drop stale blur and sobel memo in op_canny
a825e7bc5 feat(api): pipe video and camera containers into Graphics
fe41de856 feat(kriya): add capture_to_stream for an opened camera or loaded video
3184ac094 feat(depot): add get_associated_buffer and get_associated_buffers
07a73950e refactor(api): make read_camera return the camera container
5ea59dd4c fix(forma): export entry factories and plot data range
da4d9692a feat(api): add dialog-backed read_camera to Creator
8c2abce03 feat(api): add choose_camera to Depot
782128afa feat(forma): add a window list picker
fa143c505 feat(io): offer default capture modes from the camera source
874651452 fix(api): add missing DLL exports across public interfaces
d13a7acd0 feat(io): enumerate cameras through libavdevice and open with a mode fallback
cffeaa7c3 refactor(vulkan): remove unused VKFramebuffer wrapper
b9f268943 refactor(parallel): drop Execution.hpp and call std parallel algorithms directly
22a3e9f50 ci: allow selecting target platforms when dispatching the PR build.
4ff06a870 build(macos)!: replace oneDPL with native libc++ parallel algorithms
b304db555 build: pass -fno-pch-timestamp to clang when ccache is enabled
e5808d26d fix(yantra): skip unallocated buffer slots in descriptor writes and barriers
79dc23381 fix(vulkan): enable fillModeNonSolid when supported and fall back to fill otherwise
1243e5b9b build(macos)!: restrict macOS support to Apple Silicon
8434bb92b build: remove GLFW from setup and CI scripts
8ad93050d docs: remove GLFW references and completed macOS help wanted
19abdc536 refactor(windowing): remove GLFW backend
67c1479d1 fix(windowing): report Cocoa horizontal scroll as positive right
90b1107a4 feat(windowing): generate Cocoa key repeat from KeyRepeatConfig
e1cde0118 build(macos): make GLFW backend opt-in
12163ecd8 feat(core): default to Cocoa windowing on macOS
9000ed760 feat(core): wire Cocoa backend into WindowManager and Vulkan
928b45c50 feat(core): add COCOA windowing backend selection
6e66716d1 feat(windowing): add native Cocoa window backend
435368e0a fix(parallel): run dispatch_main_sync inline on the main thread
88e4b3230 fix(windowing): complete Cocoa key mapping and fix HIToolbox include
5c0a49800 fix(forma): define Atelier singleton out of line
323aa1d7d WIP: add Cocoa key mapping for native macOS windowing
6d0e3e854 fix(text): find macOS fonts with compact filenames
eb3232963 fix(core): keep macOS main loop active during subsystem shutdown
6b3610316 update examples to new API and tutorial prototype
8bb03ab5a refactor(api): replace opt-in gate macros with explicit includes and opt-out groups
0767b551b feat(api): let the dialog loaders choose a file for samplers, tap sets and composites
21076e971 feat(buffers): add MarchConfig, Spot and VolumeGridBuffer::influx
8ec8f5df7 feat(kinesis): add generate_explicit_surface and fix generate_tube on coincident points
cf6e7a442 refactor(nodes): rename mock process to exclude_output_from_graph
e9da510db feat(depot): let choose_video decode the audio track
3164baa6a refactor(io): rename LoadConfig and return video loads as a pair
e7e8644db feat(io): add SpatialReader for time sampled Alembic points and curves
0bfee0a46 feat(nexus): bring state encode and decode up to the current classes
a0d838c66 feat(nexus): anchor and bound point, path and instance buffers.
80159ec1b fix(nexus): let placements on one render processor stack and release independently
545560334 chore: update the examples submodule
70d270b29 fix(nexus): settle who owns an Expanse and what removing one does
cdbe1eb3f feat(nexus): read the bounds of point clouds for Hull
bfea325bf fix(nexus): give an Expanse one id for all the Fabrics it is on
b927ce2fc feat(nexus): let an Expanse perceive its occupants
c4aec5a1a fix(nexus): pass entity ids, not spatial index ids, to Expanses
e6202ce0a feat(nexus): add Mantle, an Expanse whose box places a buffer
dbb52f3f0 feat(Nexus): Add Expanse encoding/decoding to State
29244f304 feat(nexus): add Hull, an Expanse whose region is a buffer's bounds
144518fba feat(nexus): add Expanse bounds and typed crossing actions
0bb36de93 refactor(nexus): hoist buffer geometry reads into Pheme/Survey
5e8ba8d0c feat(nexus): allow Agent, Emitter and Sensor without functions
84afe74f7 feat(nexus): attach buffers to Emitters and add bind_influence_block
df0aeccae refactor(shaders): read the lit influence block from push constants
5242b3dac refactor(nexus): replace the influence UBO with a push constant block
9348f0a04 refactor(nexus): merge context headers into their carriers
bbeb690ed refactor(nexus): place attached buffers through the geometry transform
677113d2e feat(field): evaluate GPU fields through the render geometry transform
3a660118c feat(graphics): add MAT4_F32 to GpuDataFormat
d97be28cd update(Instancing): Forward geometry transforms to instance shaders
3959fbc9e feat(shaders): apply geometry transforms to meshes and volumes
47f2e9935 feat(render): apply geometry transforms to milled shapes
88b90b66a feat(shaders): apply geometry transform to lines
5f9ff977a feat(shaders): apply geometry transform to basic vertex shaders
90ab3749a feat(render): publish an optional geometry transform in the render UBO
bdf75173c fix(portal): stop destroying compute pipeline layouts twice
e133b8577 feat(nexus): add field targets for influences
a8d42b27d feat(nexus): add typed influence and perception
7690ee6ad feat(nodes): bind parametric fields on GpuFieldOperator
f3d999578 feat(kinesis): add parametric field form MF_FIELD_P
d2b755073 feat(nexus): attach an Agent to an existing buffer
fc833be22 feat(nexus): express attachment offset in the Agent's frame
0c77039e0 feat(nexus): add Attachment for placing an existing buffer on an Agent
1f4eb434a fix(nexus): index entities that gain a position after wiring
9d43f307b feat(kinesis): add area-weighted surface centroid
487805d58 feat(kinesis): add strided vertex centroid and pivot transform
d22d33c82 fix(filters): read IIR feedback taps one slot back after history layout change
a3461f9ed refactor(kriya): remove CycleCoordinator
5a26c51eb refactor(yantra): remove obsolete VisionSorter
614d68b91 refactor(yantra): remove obsolete operation type registry
ed4db1c84 feat(yantra): add aggregate configuration constructors for core operations
7a978b71e refactor(api): remove the Yantra facade
daedceb32 fix(journal): omit empty source locations from file logs
5015dee07 feat(journal): add component and context include filters
79cfbd238 fix(graphics): honor Vulkan validation configuration
fd010d902 fix(core): shut down Portal::System when Engine ends
47b1a8428 feat(api): expose Chimera and TextureArrayBuffer to users
eacedf688 refactor(kriya): feed Chimera layers from a pipeline dispatch instead of a metro
b4369386f refactor(kriya): feed Chimera layers from a pipeline dispatch instead of a metro
3a1738cde feat(kriya): add BufferPipeline::end to cancel a running pipeline
fca1ab223 feat(kriya): let Chimera own its pipeline and the array it feeds
dd8f983b6 feat(kriya): add Chimera, which assembles the layers of a texture array from many sources
e86459782 fix(buffers): create the texture array before the processor, and give layers their own fit and data
b82874b60 feat(kriya): route frames and GPU images into the layers of a texture array
b523cf38a feat(buffers): add TextureArrayBuffer, a texture buffer whose image is a stack of layers
fff18b121 feat(graphics): plan how an extent fits another in SamplerForge
b2b095fb3 feat(graphics): blit between images and upload into one array layer
7ea9e7667 fix(staging): use lock-free readback handoffs on macOS
3bcc8a448 feat(kriya): capture a camera or video file straight into a stream it creates
18e07db75 feat(kriya): render config and display auto-registration for graphics operations
12b4d6db6 wip(buffers): add TapArrayBuffer, a texture buffer whose image is a stack of layers
74128187f fix(kriya): keep running operations that have no input data for audio
d7a20f7dc feat(kriya): graphics sources and targets for BufferPipeline operations
067ea191d feat(kriya): run BufferPipeline at frame rate
719b489d8 refactor(kriya): make capture retention helpers work on any element type
9b909ca6b feat(kriya): add graphics and video data helpers for BufferPipeline
55d4ff44e feat(kakshya): display a live DynamicVideoStream through the video hook
f8fc982b3 wip(kakshya): add DynamicVideoStream and FrameSeekProcessor
c202b1f79 feat(buffers): add write_* routes to DataWriteProcessor for fields, slots, meshes and pixels
56502acb6 feat(buffers): add DataReadProcessor for per-frame host snapshots of GPU data
8e36efd66 refactor(buffers): report live vertex counts from SDFMeshProcessor and its buffers
77a7cd4da feat(nodes): add get_mesh_data to MeshWriterNode and MeshNetwork
1f7b154ed feat(kakshya): add ImageData::from_bytes
5eb7fe77c feat(buffers): add buffer, slot and handle conversions to staging utils
bcd9052f0 refactor(kakshya): add ImageData::allocate and use it in TextureLoom
53ec47081 refactor(kakshya): move ImageFormat beside ImageData and alias it from Portal
1932e8270 feat(portal): add readable_format and typed download_image to TextureLoom
ae2a37dc6 refactor(kakshya): move ImageData to NDData and alias it from IO
d634f10e3 refactor(buffers): move compute mesh readback from IO into staging utils
502991d4d feat(kakshya): add VertexInsertion and decode spatial export columns through it
9d1289b24 refactor(kriya): split BufferPipeline implementation by responsibility
ed4115604 feat(api): add buffer and multichannel forms of record_into
1134fe1f1 feat(api): add lookback taps on live rings
e7df92f70 feat(kakshya): add repeating time maps with a changing repeat length
4f09a989d feat(kriya): give TapSet live speed control and multichannel taps
0b638bec1 feat(kriya): add TapSet for several independent taps on one stream
df50cb558 feat(buffers): make channel mix normalization switchable
4c7ace7cf feat(kriya): support lookback taps and commit on live DynamicSoundStream rings
a01b3656a feat(kriya): make DynamicSoundStream rings writable from BufferPipeline
1abf16d8a feat(kakshya): drive StreamSlice playback from a time map
a64b14f2c feat(kinesis): add TimeMap tendency and TimeMaps factories
7e33fc5f8 fix(buffers): apply live StreamSlice edits to playing voices
bcc143879 chore(): update submodules to new vision insight examples
e3e392e2c refactor(vision): rename VisionRequest to VisionQuery
30f26b089 fix(vision): stop sharing images between request sequences that overwrite them
1914b6b3b feat(vision): extend VisionExtractor to every VisionAnalyzer output
f73dcf5fe feat(vision): region masks on HarrisResponse and ExtractPeaks
eeca64448 feat(vision): wire colour segmentation and region confinement into VisionRequest/VisionAnalyzer
6be411f0c feat(vision): multichannel Threshold/ThresholdAdaptive/ThresholdOtsu, HSV-led flow pyramid
3dbc92232 feat(vision): add Confine op, pre-run region confinement on GPU
a91c1885f feat(vision): expand VisionAnalyzer with GPU-reduced appearance/shape/track stats
06c002090 refactor(vision): group export buffers into BufferOutputs, wire export_keypoints
2d11a6dbb feat(vision): let resolve() share leading GPU work across intents
092bb2089 fix(vision): give every image-producing VisionOp its own VisionResult slot
79c428104 feat(vision): make VisionExtractor's methods require analysis, not accept invented geometry
6d291d4a5 feat(vision): make VisionExtractor a real Operation, add sample() and patches()
b0b0f77a9 feat(vision): make VisionAnalyzer container-native, matching EnergyAnalyzer's calling convention
038f5fa81 feat(vision): give FindElements and DetectFeatures real GPU-derived shapes
4f431f0a8 feat(vision): retain ConnectedComponents' label buffer and boxes for downstream use
a2034031d feat(vision): add VisionAnalyzer, a real GPU reduction shader, and its VisionContext types
e8089793e feat(yantra): add FunctionalOperation
8897738e0 feat(vision): retain the gray frame across sequences, add VisionAnalysisContext/VisionAnalysis
d3bf3caff feat(vision): add VisionIntent and VisionRequest resolution
9055458b8 fix(vision): align CPU contour sequencing and parent sentinel
c078bf475 refactor(vision): use parameter structs throughout the fluent builder
5a0198de2 fix(vision): restore CPU correctness and complete CC and contour support
aa6a8d4e2 refactor(yantra): fold dependency-dispatch async path into execute() contract
e3a0914e7 refactor(yantra): migrate ComputeMatrix async tracking to AsyncGroup
7d9805b18 refactor(io): migrate save-task tracking to AsyncGroup, add independent IOManager shutdown
c7b513ac8 feat(transitive): add SweepList and AsyncGroup for lock-free async task tracking
1f9cf279f fix(io): correct video capture stop path, disambiguate stop_capture, drain all captures on shutdown
5baaa9096 refactor(io): forward-declare IOManager.hpp's concrete-only dependencies
9a72cda3e refactor(io): extract IOManager mechanics into IO::Detail (phase 1)
595c867a7 refactor(io): reorganize IO/ into semantic subfolders by backend coupling
dbf47000b feat(kakshya): support dynamic values and BLOB fields in Composite
73bd16050 feat(yantra): add schema-aware Composite data support
e2f42f95a build: enable optimized Unix development builds with mold available
4a8ded206 feat(vision): select CPU or GPU executor through VisionSequence
9ef19b15c refactor(vision): split GPU dispatch by operation family
ba5097571 perf(Yantra/Vision): Replace bitonic sort with K-round top-K select for contours
eb05fb932 perf(vision): batch image descriptor updates into one call per dispatch
1b594021e perf(vision): run FindContours trace, sort and render as one DEPENDENCY sequence
a943e1357 feat(vision): add otsu_apply.comp, missed from the DEPENDENCY rework commit
41d2451db perf(vision): run Open and Close as one DEPENDENCY sequence
4492d84d9 perf(vision): batch descriptor set updates into one call per dispatch
68d356c8c perf(vision): run Otsu threshold as one GPU-resident dependency sequence
3ae138c0e fix(vision): guard dispatch_async's host-read barrier against shared bindings
605c6b1da perf(vision): prefer GPU local contour tracing buffers
eab0259ae perf(vision): batch connected components dispatch stages
b148f001f fix(vision): trace every compacted contour across workgroups
0d0b56ecb fix(vision): remove component ID spin waits, bypass cc results when contours follow
5b5e6e6b7 wip(vision): indirect group counts and opt-out host readback for TrackKeypoints
19c53c050 feat(vision): export tracked keypoints to a device resident buffer
012fef4da feat(vision): forward-backward track check and motion-gated flow visualization
1aaf502bf fix(yantra): never read and write the same image in one pixel dispatch
def552aae fix(yantra): feed the Convolve2D blur a 2D kernel
c4e417ae3 fix(graphics): finish image lifecycle cleanup
997f24d91 fix(portal,kakshya,yantra): serialize container image refreshes, stop evicting
a04a8088d refactor(portal,kakshya,yantra): hoist image reuse into TextureLoom
53f24f964 perf(yantra): place GPU-only flow buffers in device-local memory
71e6ceba9 WIP(Yantra): GPU pyramidal Lucas-Kanade tracking and dense optical flow
4118f53d5 fix(yantra): stage the downsampled image as the next step's input
1a616b350 feat(kinesis): add dense optical flow op and pyramid layout
dd7d13048 feat(yantra,kakshya): reuse GPU images across dispatches in TextureExecutionContext
3558f3344 feat(yantra): add fence-returning DEPENDENCY dispatch path
b84c7167f feat(api): generate Creator factory overloads from constructors
27c062f3c refactor(various): redirect bare-filename writes to data/out and data/log
30a0c5a74 fix(macos): Specialize double return path in DelimitedTextReader
7ebba5498 quickfix(build): include charconv for portability, and dll expose early for Windows
375b7f2d4 feat(api): save CompositeContainer as CSV or TSV via IOManager and Depot
449ea8f5f feat(io): add DelimitedTextWriter, CompositeWriter for CSV and TSV
8e50b7f0d feat(io): add CompositeWriter, the typed writer contract for Composite files
f90f7ad61 feat(api): load CSV and TSV through IOManager, Depot, and vega.read_file
77e030267 feat(io): add DelimitedTextReader, CompositeReader for CSV and TSV
aadb273b9 feat(io): add CompositeReader, the FileReader boundary for Composite data
1b342134d feat(kakshya): add CompositeContainer, an NDDataContainer<CompositeArray>
861a5eb3a feat(kakshya): add DataFieldTraversal, generic windowed access over T
a7f221490 refactor(kakshya): use pch ArithmeticData for composite fields
676716cb7 refactor(kakshya): template NDDataContainer on element type
7a0dd10ab feat(kakshya): add Composite, a heterogeneous named-field record type
72442df39 chore(io): update stale CameraReader references to CameraSource
17433c33b feat(api): add vega.read_camera and vega.read_volume
9d7d4a8a1 refactor(io): template the single-shot writer registries
c9205be7f feat(io): extract CameraSource interface for pluggable camera backends
84cd4d3ea refactor(kinesis): rename Relation.hpp to Covariation.hpp
e63e4dbab feat(relation): make slot construction, lookup, and WalkOperator start more expressive
7ec51c3cf feat(relation): add WalkOperator
bee10a4fa feat(relation): add RelationNetwork, a dynamically growable slot-and-operator host
3cb708bdf feat(kinesis): add Weights, a stochastic transition/routing table
01f3c5601 feat(forma): aggregate mapped control ranges into write processors
7f9017fba docs(Forma): document Tend<T>
490e44673 feat(Forma): introduce Tend<T>, the fourth Collapsible/Scrollable/TextField sibling
b7dfe7051 feat(Forma): add Atelier::create_surface(WindowCreateInfo) and Atelier::track<T>
fc8c167bd feat(Kinesis, Forma): make drag-based Geometry:: factories scroll-offset aware
d37939550 refactor(Forma): unify Surface construction through SurfaceConfig
a9abfc883 refactor(Buffers/State): retire the generated emit presets, add the float ramp emit
921f6446c feat(api): support explicit model parent references
da5737d9b feat(API): add Mint, a structure-building member on Creator
02f8713f9 refactor(Buffers, Nodes): prepare for config-driven wiring
d1d66e378 feat(API): add Evolve, a config-keyed wiring member on Creator
e470bb4bd fix(Kriya): clamp metro interval to one processing unit
c77d819a0 feat(Buffers/State): add GridConfig for RelaxationGridBuffer
7faf795ab feat(Buffers/State): give the relaxation step a single generation owner
df16674cb feat(Kinesis): add Relation.hpp, the multi-stream relation primitive family
fc5326542 feat(Kinesis): add feature-space primitives for Sandhi
25039150e fix(forma): rebuild closed inspector views on reopen
39ba861f2 fix(forma): finalize closed surfaces after event dispatch
2fb286bba feat(Window close): detach graphics state and harden Forma event dispatch
a0ddd7784 feat(Buffers): detach render processors cleanly from closed windows
27213c5ca feat(Forma): stop presentation work when a Surface window closes
a382d11a1 refactor(Buffers): Decouple render visibility from buffer processing; add presentation refresh
ea36d6d81 fix(Buffers): safely resize persistent text staging buffers
6a86ea56e perf(Portal::Text, Portal::Graphics): reuse staging buffers and avoid blocking GPU stalls in press/repress
36dbb0aba feat(Core::Windowing, Portal::Forma): coalesce resize-end and re-render text labels on it
edf3b578c feat(Core::Windowing, Kriya, Portal::Forma): wire window resize into Kriya and Context
fdceaa402 fix(Core::Engine): gate shutdown wait on Ctrl-C, not stdin
82e655993 docs(Portal): sync Text and Forma guides with landed API
210cf0bfe fix(Portal::Forma): skip Entry re-repress when the composed value is unchanged
1a702fa69 feat(Portal::Forma): add Context::to_ndc_rect for pixel-exact placement
7dd458f29 feat(Portal::Forma): make paint order track Layer::bring_to_front/send_to_back
b21188770 feat(Portal::Forma): cascade Layer::remove through relate() closures
21a2943cf feat(Portal::Forma): create_text_field() builds and buffers TextField's Scrollable
2420310ce feat(Portal::Forma): wire Up/Down, click, and wheel to TextField's caret
1a02863e2 feat(Portal::Forma): add caret to TextField
af831fa42 feat(Portal::Forma): make Scrollable fluent, add TextField::scrollable()
bedd77962 feat(Portal::Forma): wire scissor+scroll into TextField
6c9688362 feat(Portal::Forma): add real TextField, replacing the wire_text_edit trial
eb75daf03 feat(Portal::Text): add TextEdit.hpp for editable text buffer operations
f6eb83fe7 feat(Portal::Forma): add scroll_indicator geometry factory
94c84bd48 feat(Portal::Forma): add draggable scroll indicator to Scrollable
407c62f59 feat(Portal::Forma): Collapsible labels compose background+text together
f00373a74 feat(Portal::Text): composite a solid background beneath live text
ef5edb3f1 refactor(Portal::Forma): rename and relocate QueryUtils to Primitives/Entry
7d704ee07 feat(Portal::Forma): add Scrollable primitive for scroll-offset viewports
523aaf805 fix(Portal::Forma): keep Mapped<T> hit-test bounds live past the first frame
5a4272036 feat(Kinesis): add CPU-interactable 2D scroll state and offset math
3a489d567 feat(Graphics): add optional per-buffer scissor clipping via RenderConfig
80096c9b2 feat(Portal::Forma): add press_and_hold key binding
bd5965858 feat(Portal::Text): add text coordinate and hit-testing primitives
abee71f01 feat(Portal::Text): add text range extraction with layout quads
bb7793dd3 fix(Portal::Text): stop atlas growth and default-atlas swaps from corrupting stale quads
fe3411901 feat(Portal::Text): add byte offsets and per-range style spans to layout/ink
d5a09adb6 fix(Text): Make text wrapping respect upcoming glyph bounds
f8bbfea98 feat(Portal::Text): control-codepoint filtering and tab stops to text layout
d137cbcae feat(Portal::Text): add UTF-8 encode/step helpers to TypeSetter
bade47e18 feat(input): add platform text input events and focused text dispatch
b17aa0ee2 chore(examples): Add multi topology and assembly network examples
5d5a1fee6 fix(Buffers,Core): let an empty GraphicsOperator present a window
6d3f42d76 feat(Nodes): add GeometryLeafNode, AssemblyOperator, AssemblyNetwork
90e5b166d fix(Portal,Buffers,Nexus): triangulated POINT_LIST across every buffer class
7bd4513d9 refactor(Buffers,Nodes): mill macOS line geometry instead of expanding on CPU
b612e0b88 refactor(Buffers): order the field pass in the flat chain, spans per operator
91385783f fix(Portal): synchronise PrimitiveMill against the draw that reads it
507ea427e feat(Portal): joined ribbons in PrimitiveMill, wired through RenderProcessor
79555025e feat(Buffers): optional span triangulation on RenderProcessor
8b61c60ce feat(Portal): PrimitiveMill reduces mixed-topology spans to triangles
22e1e42ee feat(Kinesis): emit curve tangents alongside sampled positions
cf9a7571e refactor(Buffers): open RenderProcessor hooks for generated geometry
0449b0b93 feat(Network): per-topology draw runs consumable by draw recorders
b23196167 feat(Network)TopologyRun and GraphicsOperator::topology_runs()
f62c71eef chore(repo): improve contributor and developer workflow
cd7d5e574 fix(IO): resolve Windows build issues for spatial capture
f94acfd74 chore(examples): Update to export modelwriter-spatialcache example
322838967 fix(io): export bound diffuse textures alongside mesh saves
f8b32c892 feat(io): wire SpatialCache into IOManager and Depot
6b332b4a4 feat(io): add RelaxationGridCapture, a single-consumer-safe grid capture
c5452f2fe feat(nodes): topology-aware curve export for PathOperator/TopologyOperator
9b7437d7a feat(io): add SpatialCache producers and time-sampled capture
d347a00b5 feat(io): add SpatialCache for time-sampled Alembic-backed spatial data
894f0953e feat(buffers): expose RelaxationGridBuffer cell stride and rule/emit source
db1917c19 feat(nodes): add extract_vertex_attributes/velocities to GraphicsOperator
033f963bd feat(nodes): add extract_vertex_attributes/velocities to GraphicsOperator
79baefc5b build(deps): add Alembic dependency across build and packaging surfaces
4b51b00d8 refactor(io): unify IOManager mesh-save naming and make it fully async
3a3e9e43d feat(io): add dialog-backed mesh save to Depot
340fd530e feat(io): add ComputeMeshBuffer readback for mesh export
2c1ff5fbc feat(io): wire mesh export into IOManager
ab1dfba13 feat(io): add ModelExport save_mesh/save_mesh_snapshot free functions
b9c68b0fb feat(io): add ModelWriter and AssimpModelWriter for mesh export
8aea29206 feat(buffers): expose MeshBuffer::get_mesh_data() accessor
66b6beee3 feat(io): warn on mismatched per-grid transforms in VolumeReader
9922d300d fix(io): correct AFFINE transform translation extraction in VDBArchive
17f3a5069 fix(io): thread precision-loss detection through VDBArchive narrowing
1a493f773 feat(buffers): add VolumeGridBuffer::ensure_fields
64bf821f1 fix(build): exclude tinyvdb_io.cc from the tinyvdb target
25afb001c feat(io): add IOManager volume load/save and Depot dialog wrappers
abc4770bc feat(io): add IOManager::load_volume
698c08a1c feat(io): rename VolumeExport to VolumeTransfer, add upload_volume
214b3f780 feat(io): add VolumeReader for .vdb import
f132cd7ca feat(io): add tinyvdb read path to VDBArchive
8401dea91 fix(build): guard the optional tinyvdb NOTICE install
c1d034c5b build(vendor): strip tinyvdb's dead get_data declaration
29343c76a build(deps): group tinyvdb under DEPS in the VS solution
fb808a09b refactor(buffers): batched multi-field readback
84dbd1e56 feat(io): async volume save and managed capture on IOManager
a9610b77f feat(io): VolumeCapture for numbered .vdb sequences
ebf8ec790 refactor(io): move tinyvdb interop behind a VDBArchive RAII boundary
41b4ffc1d feat(io): write LatticeSemantics as OpenVDB grid metadata
559e3786e feat(io): VDBWriter, writing every volume field as a named .vdb grid
916967905 build(vendor): tinyvdb for dependency-free VDB writing
79bd07995 build:(vendor) tinyvdb for dependency-free VDB writing
454de4534 feat(io): download_volume and save_volume
99f1f2d6c feat(io): VolumeWriter interface and extension registry
49eea6ce0 feat(kakshya): VolumeData host representation for lattice-sampled fields
ebc72a489 refactor(buffers): field semantics and stride accessor on VolumeGridBuffer
96355aefb feat(kinesis): LatticeSemantics for volumetric value classification
c173ac815 chore(examples): Upgrade all organism and fillament examples to the newest features
ac48a6e9e fix(Nodes): back PathGeneratorNode and TopologyGeneratorNode with std::vector
81609af90 refactor(Kinesis): parallelize proximity graphs, drop Eigen from the topology hot path
e985e7d24 refactor(Kinesis): move MotionCurves evaluation off Eigen onto a planar SIMD core
9bf53ae8a refactor(PathGeneratorNode): preallocate vertex writes, split attribute updates
1120e8381 refactor(Kinesis): MotionCurves evaluation around per-segment GEMM
7d6ba22c2 fix(Nodes): take the PhysicsOperator access token for the whole process() step
1e712f798 perf(Buffers): incremental geometry upload skips the whole-buffer re-aggregate
c3f815817 wip(Buffers,Nodes): per-group dirty ranges + incremental network geometry upload
76e740ceb update(examples): Start organism test trials
bfa5c997f docs(Buffers): trim development-history asides from the spatial-hash/claim/population doxygen
edb9abaca refactor(Buffers,Portal,Nodes): dedup the GPU field compute processors
6b469daaf feat(Buffers,Nodes): transfer cross-cluster claim hops a vertex instead of destroying it
af479c17b feat(Buffers): spatial-field pipeline reaches PointCloudNetwork
13c0bdb1d refactor(Nodes,Buffers): fold SpatialFieldConfig into GpuFieldOperator, drop ParticleFieldOperator
91d948283 refactor(Buffers,Nodes): network-agnostic GPU field pipeline, drop ParticleGeometryBuffer
bca3fad68 feat(Buffers,Nodes): GPU-local population dynamics decoupled from CPU seed state
0dff12d75 feat(Nodes,Buffers): cluster-scoped GpuFieldOperator bindings, any GraphicsOperator
c4c6cb064 feat(Buffers,Nodes): cluster-aware particle hashing across mutation and density
1095a7abd feat(Nodes,Buffers): persistent CPU-side accretion mass, capture growth, examples
e74b0ac48 chore(examples): sync particles and shader tests
b2fa81aa4 feat(Nodes,Buffers): live-tunable particle GPU config via operator setters
2ce2e066b feat(Nodes,Buffers): ParticleFieldOperator + ParticleGeometryBuffer, unified particle GPU config
a9e80ae72 feat(Buffers): deterministic pairwise claim protocol for particle absorption
4d1b07826 feat(Buffers): uniform-grid spatial hash for particle neighbor queries
f7450e39d refactor(VertexLayout): generalize position word-offset lookup
7563d5f88 feat(NetworkGeometryBuffer): declare named auxiliary state fields
5243d1462 fix(ShaderProcessor): clear rebuild flag on first pipeline init
896606dac feat(Buffers): VertexFieldProcessor, generated field shaders over a vertex range
fad25b7db feat(GpuFieldOperator): accept fields of position and time
b06a410a4 refactor(NetworkGeometryProcessor): reuse staging, survive non-geometry chain operators
9524fa75f feat(Kinesis): TemporalField for expressions of position and time
e058b7b30 refactor(Buffers-facing prep): GpuFieldOperator declares only, processor dispatches
881491d8b feat(Nodes::Network): GpuFieldOperator, Tendency fields as a generated compute pass
c4a5d2c43 refactor(FieldOperator): accept a target mask on bind and unbind
18dbbcf8e feat(Kinesis): FieldTarget becomes an open bitmask, moved out of FieldOperator
bc5c6d447 feat(pch): MF_BITMASK_OPERATORS for scoped enums
5b8a60f02 refactor(ParticleNetwork): run the operator chain, unpin the primary
ae7644b09 feat(Kinesis): DualField, one authored expression bound to both backends
2b6fc250a feat(Portal::Graphics): emit standalone functions before main in generated GLSL
0c4d1a982 refactor(Vision): derive step adjacency at the point of use in vision sequences
ed9ec0919 fix(Yantra,Vision): GPU-convert the seed frame to rgba32f storage before the pipeline
0b0eafb87 fix(Yantra,Vision): Harris peak reset and stale ExtractPeaks config entry
dbfb3af22 fix(Vision): make CC/keypoint compute shaders portable to NVIDIA
d6c40b94c refactor(Yantra,Vision): Scope GPU dispatch memoization to one walk
7789b3e7f fix(Vision): hash all parameters in hash_vision_step
7bf81861f fix(Yantra): deferred-step resume in VisionGpuExecutor
3b5064be8 refactor(yantra): hoist shader elision state onto VisionGpuContexts
7e9037eb3 refactor(yantra): extract Canny from the dispatch switch PART III
e89e5be33 refactor(Yantra): extract memo-writing vision ops from the dispatch switch PART II
f762d6ff8 refactor(Yantra): extract terminal vision ops from the dispatch switch (PART I)
efce733a8 refactor(yantra): thread VisionGpuExecutor::run through GpuVisionPass
c3b4ae348 refactor(kinesis): thread VisionExecutor::run through CpuVisionPass
62d08f37f refactor(Kinesis): extract vision context types into VisionContext.hpp
23de1c149 feat(Yantra/Kinesis): deferred vision steps
a2de3d385 fix(vulkan): include windows.h before vulkan_win32.h in VKDevice
da0a6c668 docs(config): document GPU selection and device extension fields
5c6f74d5d fix(vulkan): validate user-supplied device extensions before createDevice
9dd737dce fix(vulkan): resolve presentation families at device selection, not per surface
24e8e422a feat(vulkan): configurable GPU selection with surfaceless presentation filtering
d15516a11 feat(graphics): device selection fields on GraphicsBackendInfo
1361bef3c docs(forma): update Forma guides for Form, create, and layout additions
be88194d8 feat(forma): point and crosshair follow hover, not drag
492014514 feat(forma): factories return Form, add Forma::create
9e707a283 refactor(forma): split Geometry into declarations and factories, add Form
218bd60f1 refactor(forma): move plot adornment construction into Atelier
605024672 Forma: extract session state into internal::Atelier
19b49dbed Forma: add Context::wire_drag and Kinesis projections
20d8a36d9 Forma: add cursor-scoped overloads for Collapsible and value rows
dfed8ae7d Forma: anchor-relative placement and column-scoped layout
bb9225453 fix(wayland): read the display socket in poll() instead of relying on the WSI
4bdc392a4 chore(submodules): Update examples to new api
191afeb4a fix(filters): correct feedback history, coefficient routing and growth
9a59904a2 chore(nodes): remove WindowGenerator
8604326ff refactor(analysis): window frames via Kinesis::Discrete
cfc5093aa feat(kinesis): boxcar support region and ramp generation
dc5a84d48 feat(kinesis): FIR design and direct pole placement in Coefficients
e8d0b79be feat(kinesis): filter coefficient design in Discrete
b2c6363d0 feat(filters): expose mutable coefficient spans
fe879ce58 fix(filters): normalize a[0] at the setter
cf547b568 fix(filters): cache post-gain output in IIR and FIR
413efd189 Fix CMake package config and shader paths
27555c849 fix semicolons
6947d7a79 chore(API): Expose more headers as global
91a9a333f fix comment instruction
0c59b2ad4 detect if JACK is installed during Arch installation and suggest pipewire-jack if so. this and the previous commit solves #162
b41f6524e added missing header reference to example project
e8c918ce2 chore(API): Expose more headers as global
140bc8300 feat(Kinesis): add SymbolicTrajectory, wire into MotionChannel
0c029cb19 feat(Kinesis::Spatial): add Lattice2D
e9dad5161 feat(Kinesis): add MotionChannel, builder that wires Estimate + Differential + HampelFilter
833bf697b feat(Kinesis): add HampelFilter, screens Differential output for isolated spikes
24d82d7c5 fix(Kinesis): curvature scale sensitivity and confidence units mismatch
4291bd07c feat(Kinesis): add Differential, wire Estimate as its noise-filtering input
285f38e9a feat(Kinesis::Stochastic): add Estimate, the analytical counterpart to Stochastic
61355b59f feat(pch): add scalar_t<T> for generic scalar multiplication/division
9b6301b93 refactor(Kinesis): relocate Stochastic into Stochastic/ subfolder
9b6fcc0c2 fix(input): correct HID descriptor parsing for tablet layouts
de417f269 feat(input): tablet backend and node, end to end
e3a5e4d07 feat(nodes): TabletNode, frame contract moved to Core/Input
cf3d80cf9 feat(input): tablet backend over HID report descriptors
d02ae53ac feat(IO): Plumb requested pixel format through the FFmpeg read path
b2b5afcdf fix(IO): Derive CameraContainer format from the requested pixel format
bc08fb287 fix(Kakshya): Accept depth modalities in FrameAccessProcessor
b036000da refactor(Stream): Make VideoStreamContainer format-aware
504017eb7 refactor(Buffers): derive texture byte size from the destination format in VideoStreamReader
814d56dd1 feat(Kakshya): Add format predicates to PixelStorage
153c3e37c feat(IO): Map AVPixelFormat to ImageFormat in VideoStreamContext
bcc0a83c8 refactor(Kakshya): take frame byte size from the container in FrameAccessProcessor
eb182816d feat(Kakshya): value ranges and depth modalities to NDData
e53e25721 refactor(Kakshya): Extract pixel storage helpers from TextureContainer anonymous namespace
8388f1fee chore(examples): update new sim tests
ca5ad82ce feat(API): Add typed field refs and setup_flow to VolumeGridBuffer
414dbd4df fix(buffers): generate_box vertex_count; rework RaymarchBuffer onto MeshBuffer
685416634 refactor(Utils): Defer the fence wait on volume field uploads
e1fd8f2fb refactor(Rendering): Parameterise depth and cull on view transform setters
0f910c851 feat(Grid):InfluxProcessor: continuous shaped contribution into a lattice field
d781b85ef feat(Grid): WallProcessor: free-slip condition on the six lattice faces
2f367b69c feat(VolumeGridBuffer)::accumulate for authored field injection
640d66478 feat(Grid): raymarched volume rendering: RaymarchBuffer, RaymarchProcessor
1ea7e00e4 feat(Grid):BuoyancyProcessor: Boussinesq body force accumulate into velocity
6e5b51728 feat(Buffers): per-cycle feeds to ShaderProcessor
7742329f8 refactor(shaders): mc_emit color modes with a three-color axis palette
2b46db27c feat(Kinesis): Lattice3D and route volume storage through it
a3cd2e01a feat(grid): DiffuseProcessor for viscosity and scalar blur
be0024b58 refactor(Grid): the four volume stages onto VolumeFieldProcessor
64087d12f feat(Grid:)VolumeFieldProcessor, shared shape for volume lattice stages
26a1165cf feat(buffers):SolenoidalProcessor, closing the incompressible chain
25e4dcf3d Add normal coloring to marching cubes extraction
5a70d43d1 Promote mc_emit.comp to the main shader tree
9439f7501 Add isosurface extraction and rendering to VolumeGridBuffer
2e35ae0fe Add PressureProcessor for Jacobi pressure solve
6770846b8 Add VolumeGridBuffer with advection and divergence stages
90ebba7db Add upload_back_buffer to StagingUtils
1f6947127 Add iteration and deferred submission to shader processors
9a9e4cfa1 fix(docs, scripts): Remove stale msvc19 ref, Update docs
529bc4331 docs(intro): Add dev getting started, update contributing.md
9f13e8f9a update docs
642adecbf docs: add CPU-GPU IO reference map
8743bba22 update examples
081797ca3 BufferDownloadProcessor/BufferUploadProcessor: back_buffers support
6675c00ec RelaxationStepProcessor: snapshot via mapped_ptr instead of fenced copy
6d29cba81 Add name-keyed and raw-slot GPU download primitives
1700d8963 Add Gray-Scott reaction-diffusion rule and scalar emit
361413004 Make push constant staging self-describing and mergeable
b427f757b Colour relax_vertex_emit by cell state
1bd510659 Add packed vertex emit and point rendering to RelaxationGridBuffer
9b9cc92b1 fix(compute): RelaxationGridBuffer generation stepping
e9520a082 Fix dispatch sizing and snapshot download in Relaxation processors
214a8323a Guard descriptor writes against are_descriptors_ready() in Relaxation processors
02f82561d Implement KernelOp::CompareGE in emit_elementwise_body; guard format mismatch in default case
707ed2391 fix(Buffers) initialize_buffer overwriting subclass-populated resources
84d7ee64b Add ShaderSpec-based RelaxationGridBuffer construction
e2f5a6383 Add KernelOp::WeightedBlend for Stencil-based rate-blend rules
a2373bb24 Add ShaderSpec-based construction to ShaderProcessor/ComputeProcessor
1d931ad4e Implement emit_stencil_body for KernelTemplate::Stencil
3021af274 feat(Buffers): RelaxationGridBuffer: GPU-resident double-buffered relaxation state
2b25c189e Expose allocate_raw_buffer through BufferService
b44161924 refactor(Buffers): raw buffer allocation path; make get_buffer_resources() a true overload
dc777ca3d feat(vision): add GPU-native dispatch with CPU fallback to VisionProcessor
b71595d03 feat(vision): add GPU-native dispatch with CPU fallback to ImageCVProcessor
ddd2e6ab6 Wire on_after_execute hook; add back-buffer slot to VKBufferResources
5308346b0 docs(yantra): correct GpuBufferBinding ElementType and document dispatch-core additions
3fd1cd128 fix(resonator): switch output normalization from 1/N to RMS (1/sqrt(N))
cfa34e37e fix(nodes): move mock-process flag from Generator to Node base
5e4eeaa1f fix(Yantra): MSVC build failure from incomplete DependencyStage in DependencyParams
28d4b3e9c vision: expose max_points_per_contour as a FindContours parameter
7ac29820f fix(Yantra): ShaderSpecBinding element type inference for non-float SSBOs; portal: add IndexScale kernel op; clean scan body comments
414dbe943 Add Scan and Reduction/MaxIndex kernel templates to AsmGenerator
39242861e update examples and cleanup constants
291108c1a Wire max_contours sort output into both render and structured paths
9d6223635 Fix Moore boundary walk direction and pixel-coverage area convention
9c3faae43 Resequence FindContours bindings and drop dead code/timers
5d183df75 Eliminate FindContours readback bottleneck via dense GPU compaction
da81de87f Compact FindContours trace dispatch to real owner count
432ffb2cb FindContours: fix outer/hole boundary detection correctness
679aafa3b FindContours: local hole detection in contour_march, no second CC pass
e778451ba WIP: FindContours: replace segment/link/trace chain-walk with direct march
f23fb8cba FindContours: parallelize render per-edge, add WalkNode buffer for trace
1ff370c12 AsmGenerator: fix BitonicSort SPIR-V assembly (dead-type gate, invalid CFG)
c6720b5b9 WIP: FindContours fully offloaded onto cc_pipeline, contours_ctx removed
830b06075 GpuResourceManager/GpuDispatchCore: fix barrier and descriptor indexing for shared and non-contiguous bindings
2f37a3e4a FindContours: as_image output path, sort moved to set=1
990ff8925 FindContours: move top-k sort off static local, onto structured (set=1)
a04f7e9df ShaderSpec::Assemble: add set support to generated bindings
dac2e673f GpuResourceManager/GpuDispatchCore: shared buffers keyed by (set, binding)
0cc4fe674 WIP: FindContours area/perimeter/min_area/top-k moved to GPU
0c7952db7 WIP: FindContours GPU pipeline functionally correct, unoptimized
52d3459e7 Vision GPU: wire FindContours sequencing and cc_pipeline bindings for contours
87d79a6bf Vision GPU: add gated dense pixel-precision labels to cc_final_label
57ecccb9d Vision GPU: collapse cc_compress to a single flattening pass
d57b6f24d refactor(Yantra): replace execution_metadata string keys with typed ExecutionParams
95b73149e Wire cc_compress onto CHAINED_INDIRECT for GPU-only convergence exit
4bf9f2e10 Fix cc_union non-convergence under sustained sequential contention
044a2bb75 Tighten cc_final_label bounding boxes to pixel precision
c67b3be04 Replace per-pixel CC union-find with block-based (BUF-style) labeling
228af3761 Add CHAINED_INDIRECT dispatch mode with GPU-gated convergence
89a28e4e7 update examples to stringless exec ctx from yantra
711cd2025 Remove string tags from shared buffers; index-addressed throughout
733bfeb70 Add element_type_bytes bridging GpuBufferBinding::ElementType to Kakshya sizing
c323fac55 Add CHAINED_INDIRECT execution mode for GPU-gated multi-pass dispatch
e1756e8d1 Introduce BufferUsageHint::COMPUTE_STORAGE, thread usage hints through ensure_buffer
56745c990 Unify VKBuffer::Usage and GpuResourceManager buffer hints into BufferUsageHint
2eb5951fe Add per-call gating for CC label export and debug colorization
d8396ff38 Fix CC pipeline deadlock, correctness, and readback performance
d7d9270d5 Collapse connected components into a single dependency chain
1f4d94d1f WIP: rewrite connected components using GPU union-find
09bfbeaff Extract shared descriptor binding into GpuDispatchCore::bind_all_descriptors
d0f091e76 Loosen TextureExecutionContext and ShaderExecutionContext constructor constraints
c88190c0f WIP: connected components GPU compaction, real readback confirmed
305ca7f2d fix(Yantra): Reinstate erroneously deleted shaders for connected components
dd0d55d99 perf(Yantra): cache dispatch_key to avoid repeated string construction
68b8c9706 WIP: GPU CC compaction, relabel confirmed working, box/count readback broken
263978f3e feat(vision): add GPU-resident connected components compaction shaders
6e59c2e54 feat(yantra): add cross-shader shared buffer storage to GpuResourceManager
06f629729 feat(vision): implement GPU Otsu threshold, three-stage dispatch
8f05b6ba5 feat(vision): wire ThresholdAdaptive push constants
7fe1fbb82 refactor(vision): hoist push constant structs to file scope
94803b254 feat(vision): wire Canny into VisionGpuExecutor::run()
77632fbda feat(vision): add canny_nms.comp and canny_hysteresis.comp
37f04c8c5 feat(vision): track input image alongside output in completed_ops
0ce9c66a6 feat(gpu): add CompareGEPreserve KernelOp for threshold-and-preserve
4c9f9a074 feat(vision): extract vision_relax.glsl, migrate cc_merge_borders to it
4322b87f7 feat(vision): extend sobel.comp to output gradient angle
f5ab3267a feat(vision): op-result memoization map and Downsample2x own-case fix
d09c4153b feat(vision): add hash_combine and hash_vision_step for op memoization
aa958cf8b feat(vision): two-pass GPU dispatch for Open/Close morphology ops
2e9599a42 fix(yantra): key GpuResourceManager units by shader_id when shader_path is empty
2bf35cf68 feat(yantra): add DependencyStage/dispatch_core_dependency for multi-pipeline sequences
a24d5d932 refactor(yantra): key GpuResourceManager pipelines by shader path
a0e3926b2 feat(portal): add ComputePress::record_sequence for multi-pipeline dispatch
81b68625b refactor(portal): relocate GpuShaderConfig/GpuBufferBinding to Portal::Graphics
69b45d36f perf(vision): replace CC merge-round readback loop with chained dispatch
b2f4b834d feat(yantra): add slot_binding accessor and CHAINED execute override
d91d78b29 fix(yantra): add image barrier branch to dispatch_batched INPUT_OUTPUT path
e351cdd93 Replace GPU ConnectedComponents naive propagation with tiled algorithm
496a194a5 WIP: rename ctx locals for clarity, cache CC ping-pong image per-instance
a83cf6077 refactor(Yantra): Turn GPU vision dispatch into a stateful VisionGpuExecutor class
bd798ceb9 WIP: GPU ConnectedComponents, working but unoptimized baseline
4f6b85c70 refactor(): merge stage_image_storage/stage_image_sampled into stage_image_at
a3ecee96c Introduce VisionGpuContexts; simplify run_gpu call surface
93a3caba6 Guard ExtractPeaks GPU readback when followed by TrackKeypoints
e813bec7b Yantra/VisionGpuDispatch: cache Gaussian kernels by (radius, sigma)
d7c81b701 Yantra/run_gpu: skip swap_shader/stage_image/prepare_output_image when unchanged
bfe08f0b6 Vision shaders: extract shared 3x3 neighborhood sampling
a3cdcbb04 Yantra/TextureExecutionContext: caller-configurable image bindings
4661b0e14 Yantra: index GPU resources by binding value, not vector position
6eafc52e8 Yantra/TextureExecutionContext: fold invalidate into prepare_output_image
2ec976a27 Yantra/TextureExecutionContext: replace input_as_storage bool with ElementType
ebaf41215 chore(vision): move from .comp to .comp.spv directly
48c3509d5 feat(vision): implement GPU Harris response pipeline in run_gpu
6c0503425 feat(vision): add GPU Harris corner response shaders
9c983d45d fix(yantra): prevent output/input image aliasing in TextureExecutionContext
a0575ac87 fix(vulkan): correct image download barrier for compute shader writes
a7ea0e5e4 fix(Yantra): fix ExtractPeaks dispatch size and keypoint buffer overflow
c65132288 fix(Yantra): fix run_gpu dispatch size and image chaining for manual-staged inputs
86ad78fd3 fix(Yantra): update GaussianBlur kernel SSBO binding index to 2
821c811e8 fix(Yantra/Portal): align ShaderSpec binding indices with TextureExecutionContext layout
391e7d5b7 fix(Core): add eGeneral<->eShaderReadOnlyOptimal layout transition cases
39b247242 feat(Yantra): wire ExtractPeaks GPU dispatch in run_gpu with structured SSBO readback
b272a4851 fix(Yantra): omit IMAGE_STORAGE binding 0 from TextureExecutionContext in SCALAR mode
ebb656098 feat(Portal): add extract_peaks.comp : GPU non-maximum suppression keypoint extractor
245e8ba12 fix(Portal): move Convolve2D signed integer constants to global types section
44d578c52 fix(Portal): correct SPIR-V emission for IMAGE_2D read/write in AsmGenerator
ab3c8fb1e feat(Portal): add vision compute shaders : downsample_2x, sobel, scharr, erode, dilate, morph_gradient
0b739546f feat(Portal): add shared GLSL includes for vision compute shaders
10996d607 feat(Yantra): update VisionGpuDispatch to use assembled shaders for Threshold, RgbaToGray, GrayToRgba, GaussianBlur, NormalizeRange
0f531c0c5 feat(Portal): extend ShaderSpec assembler with Convolve2D, CompareGE, ChannelDot, ChannelReplicate
69ebdb952 feat(Yantra): add VisionGpuDispatch — GPU execution layer for VisionSequence
cb9e117df feat(Yantra): add GpuDispatchCore::swap_shader for in-place pipeline replacement
622e38571 Add VisionSorter to Yantra::Sorters
b2688e592 Add KernelTemplate::BitonicSort to ShaderSpec and AsmGenerator
58d61f6f1 Extend AsmGenerator SSBO and PC support to UINT32 and INT32
0d6f503f1 Add vision_crop.comp for GPU-accelerated pixel crop
ba76c3b73 refactor(VisionExtractor): templated input, container-agnostic CPU path, GPU dispatch
835f11a7a Make m_gpu_backend protected in ComputeOperation
0bd6f117f Decouple output image dimensions from input container in TextureExecutionContext
e90d38658 Add VisionSorter to Yantra
0a5d5702c Add VisionExtractor to Yantra::Extractors
f0c0e215f Add apply_contour_mask to Contours.hpp
8b32babf4 Add normalised image coordinate to pixel Region conversion in CoordUtils
f9d1a9a79 fix(cmake): fall back to static SPIRV-Tools when shared library is unavailable
5a6c79595 chore(examples): update examples to include CV features
bc0f27ed9 fix(kinesis/vision): guard Snapshot op against empty slot
3d43c567a feat(kakshya): add denormalise_to_uint8 to DataUtils
a2de1226e feat(kinesis/vision): add Snapshot op to VisionSequence
30a2e461e refactor(kinesis/vision): move sequence topology flags to VisionSequence
10283acf4 feat(kinesis/vision): add pre-computed gradient overload to track_keypoints
924f7995e perf(Kinesis): restructure find_contours around connected_components
4b13857ec fix(Kinesis): eliminate per-frame allocation in VisionExecutor slot management
deb82da05 fix(Kinesis): channel-aware Downsample2x in VisionExecutor sequence dispatch
785b0cc86 feat(Kinesis): multi-channel downsample_2x overload with SIMD paths
70d31da05 feat(Kinesis): find_contours filtering, visited marking fix, VisionOp params
246a32af1 fix(Kinesis): correct slot sizing and subspan bounds in VisionExecutor
12468adf4 fix(Kakshya): invalidate float frame cache after read in VisionProcessor
a0fd17c6a refactor(Kakshya): per-slot float cache invalidation on VideoStreamContainer
3852f93de fix(Vision): add find_contours() to VisionSequence::Builder
475f60ed2 feat(Vision): add KernelSpec<N> and named kernel bank
32c5d6c1a perf(Vision): AVX2/NEON SIMD for Harris response computation
d5086f16c refactor(Vision): dissolve VisionExecutor step methods into run()
a65860575 refactor(Vision): rename Filter -> ImageFilter, add filter_horizontal_planes / filter_vertical_planes
bb1757b37 perf(Kinesis/Vision): fuse three Gaussian blur passes in step_harris into two
ce139812d perf(Kinesis/Vision): explicit par_unseq loops in step_harris; right-size scratch slots
189475808 perf(Kinesis/Vision): SIMD pixel ops for x64 (AVX2/FMA) and ARM64 (NEON)
8cb77e5e9 perf(Kinesis/Vision): AVX2/FMA + NEON SIMD for separable convolution passes
e65c68098 perf(Kinesis/Vision): scratch pool executor with zero-alloc pipeline dispatch
a81f510fd refactor(Kinesis/Vision): add void dst overloads to pixel and filter primitives
1e459f09a feat(Kinesis/Vision): add Downsample2x op to VisionSequence pipeline
2ab725229 fix(Kakshya): fix out-of-bounds access in VideoStreamContainer::processed_frame_as_float
3548a8f65 fix(Kakshya): guarantee DataProcessingChain presence on all container types
ff7adaf5e fix(Kakshya): correct DataProcessingChain iterator safety and lifecycle ordering
40974a2cd fix(msvc): Remove c99 array and make kernel static constexpr
c58476db6 all examples from shader testing to cpu CV validation
aa35b1d32 refactor(Buffers): rename VisionBufferProcessor to ImageCVProcessor, add persistent GPU staging
c737f87d7 feat(Yantra): add VisionAnalyzer, VisionAnalysis, and extract_scalar_vision
dab84de6c feat(Portal/Graphics): complete reduction body in AsmGenerator
c106278a0 feat(Portal/Graphics): complete TEXTURE_2D sampled image path in AsmGenerator
fb9fa39fe feat(Portal/Graphics): IMAGE_2D dual-input ops and Sub in AsmGenerator
9410b8ffe feat(Portal/Graphics): extend AsmGenerator SSBO path to vector element types
7083d724c feat(buffers): add VisionBufferProcessor
737f5a721 feat(buffers): add resolve_gpu_image and download_and_normalise to StagingUtils
253f907a5 feat(buffers): add GpuImageSource concept to VKBuffer.hpp
c9927cedc feat(kakshya): add BroadcastSource<VisionResult> delivery to VisionProcessor
668f181be feat(kakshya): add VisionProcessor
5954ee19b feat(kakshya): migrate VideoStreamContainer float cache to per-slot tracking
37742e6e4 feat(kakshya): add WindowContainer::as_normalised_float with per-slot dirty cache
0e4e46436 feat(kinesis): add VisionExecutor
f4afbc321 feat(kinesis): add VisionSequence declarative pipeline description
3f936d421 feat(kinesis): add Vision::OpticalFlow
b8fed2ab2 feat(kinesis): add Vision::Harris
ffe1996b8 feat(kinesis): add Vision::Contours
05e2a4245 feat(kinesis): add Vision::ConnectedComponents
665feef56 feat(kinesis): add Vision::Morphology
fd4941e96 feat(kinesis): add Vision::Filter and Vision::Gradient
a91c26246 feat(kinesis): add Vision::PixelOps
ffa5d743f feat(kinesis): add Vision result types with AABB2D conversion
fbc85593d feat(kakshya): add as_normalised_float to TextureContainer
1b888d383 feat(kakshya): add processed_frame_as_float to VideoStreamContainer
25c509914 feat(kakshya): add as_normalised_float for pixel DataVariant extraction
c49315fed chore(docs): Update examples and add future reference plan
8f2e92f5c feat(ShaderSpec, AsmGenerator): expand KernelOp with full GLSL.std.450 math set
74aed3453 feat(AsmGenerator): add emit_glsl_kernel for MF_KERNEL body path
7abd34a65 feat(ShaderSpec): add KernelSource and MF_KERNEL macro for user kernel bodies
1aec91717 feat(AsmGenerator): emit IMAGE_2D storage image path for elementwise ops
3407bcb86 feat(yantra): add with_gpu_backend to RuleBuilder and ShaderSpecBinding to GpuDispatchCore
9e6c67f48 feat(yantra): add ShaderSpecBinding.hpp - bridge between ShaderSpec and GpuExecutionContext
8282fb896 feat(cmake): make shaderc and SPIRV-Tools hard required dependencies
0d2889282 fix(windows): Expose more Yantra via declspec
9227114e9 bump examples to new commit
943c8a9f9 feat(portal/graphics): replace GLSL emission with SPIR-V assembly for ShaderSpec path
55345f5b9 feat(core/vulkan): add VKShaderModule::create_from_spirv_asm
1ffd06c94 feat(yantra): allow GpuShaderConfig to accept a pre-compiled ShaderID
32bbf5489 feat(portal/graphics): add ShaderSpec and ShaderFoundry::load_shader(const ShaderSpec&)
2f91fa746 refactor(kakshya): add gpu_data_format_bytes as single byte-size source for GpuDataFormat
7348f3f72 feat(cmake): add SPIRV-Tools shared library as required dependency
9d65156df refactor(cmake): use find_dependency in MayaFluxConfig for find_package deps
d83258c2d fix(cmake): correct IMPORTED_LOCATION for Windows DLL targets in config
0223b8822 refactor(cmake/win32): replace copy_runtime_dlls target with TARGET_RUNTIME_DLLS
0e5be4f81 refactor(cmake/win32): replace raw env var paths with cmake_path conversions
d5eef6a1c refactor(cmake): inline version file generation, remove generate_version_file.cmake
ca0395e28 refactor(kakshya): remove lock/unlock/try_lock from NDimensionalContainer interface
43c959263 refactor(kakshya): replace all Kakshya audio container mutexes with Seqlocks
a0cba65cc refactor(kakshya): replace shared_mutex/mutex with Seqlocks in VideoStreamContainer
3c9979904 refactor(kakshya): add Seqlocks to PlotContainer
f6f3d1567 refactor(kakshya): replace shared_mutex/mutex with Seqlocks in WindowContainer
a44ad7033 refactor(kakshya): replace state_mutex with purpose-scoped Seqlocks in TextureContainer
867a44e01 refactor(kakshya): replace shared_mutex with SeqlockArray in TextureContainer
4fca49205 refactor(Kakshya/DataUtils): remove safe_copy_to_span, fix and rename get_variant_type_index
4550dcd75 feat(Yantra/GpuExecutionContext): route native-typed input through native staging, fix output reconstruction
46a8e4f83 feat(Yantra/OperationHelper): add extract_structured_native alongside extract_structured_double
1bf76d9d6 feat(Yantra/OperationHelper): add extract_native_data for zero-coercion extraction
456957d82 refactor(Yantra): replace stale is_base_of<MatrixBase> checks with is_eigen_matrix_v
9b0afbb54 feat(Yantra/GpuDispatchCore): add native-typed staging path for non-double GPU input
5134563e3 refactor(Yantra/DataSpec): broaden Eigen support, add native extraction traits
412721b01 refactor(Kakshya): replace double-typed value_at with type-erased impl/template pair
5643d4fc0 refactor(Kakshya): replace double frame accessors with native-typed _impl layer
c843db4d1 feat(Kakshya): add DataSpanVariant, DataVariantElement, and FrameView to NDData
3fe66b8d0 refactor(NDimensionalContainer): fix dangling reference in get_region_group
5c0a0ea5d refactor(kakshya): decouple m_processed_data from m_data write paths in TextureContainer
857f0af91 feat(transitive): add SeqlockArray to SeqLock.hpp
1db820a4f refactor(journal): remove fmt alias namespace and format_string typedef
2181940a0 chore(linux): bump minimum to Fedora 44 / Ubuntu 26.04 LTS, unify CMake floor to 4.0
b4f58c5ad fix(macos): Remove erroneous std::abs<T> usage
37940f9af chore(macos): bump minimum to macOS 26 (Tahoe), Clang 17
540b2beab refactor(journal): remove fmt dependency, use std::format on all platforms
d7b4da0d6 feat(core): drop MAYAFLUX_USE_JTHREAD compat shim
351518dcf kick off 0.5.0 development cycle.