u/Motor_Pitch_8722

Hey r/wigglegrams — solo developer here!

I checked with the moderators before sharing this.

I built an iPhone app that tries to preserve the traditional wigglegram approach: capturing the same scene from several slightly different camera positions and animating those real perspectives.

During capture, the app reads the iPhone’s IMU sensors to measure how the phone physically moves. That motion data is used to guide the capture process and help select and align the frames.

The parallax therefore comes from actual changes in camera position rather than generating new viewpoints from a single still image.

The wigglegram above was captured and assembled entirely inside the app. You could create something similar manually using burst photos or video, but the goal is to automate the capture guidance, frame selection, alignment, cropping, and export.

I’d genuinely appreciate feedback from people who already make wigglegrams. Does the motion feel natural? Are there any capture controls or export options you would find useful?

Full disclosure: I’m the developer. The free version allows up to 10 wigglegrams per week, the limit resets every week, and free exports include a watermark. There is also an optional paid version that removes the weekly limit and watermark.

Happy to answer any technical questions about the IMU tracking or how the animation is assembled.

App Store:
https://apps.apple.com/app/apple-store/id6791325369?pt=128471088&ct=reddit&mt=8

Update: We’ve now shipped the on-device Gaussian Splatting pipeline in Voxelio and published a small source-available demo of the core implementation:

https://github.com/Voxelio-app/ios-gaussian-splatting-demo

The repository covers SwiftUI/ARKit capture, Nerfstudio-style dataset generation, on-device msplat training with checkpoints, SPZ export, and MetalSplatter rendering. It intentionally focuses on the core capture → training → rendering flow, while the production Voxelio app contains our more complete pose-refinement pipeline.

One problem we’re still actively working on is accumulated ARKit pose drift, especially during longer captures and in scenes with low texture, reflective surfaces, or repeated patterns.

Voxelio currently combines feature matching, Ceres bundle adjustment, and LiDAR depth constraints, but we’re looking for additional practical ideas that can run reliably on an iPhone. We’re particularly interested in:

- lightweight loop-closure detection

- sliding-window or incremental bundle adjustment

- better keyframe selection and rejection

- LiDAR-assisted pose constraints

- fast ways to detect when a capture has become geometrically inconsistent.

If you’ve built something similar on top of ARKit, we’d really appreciate hearing what worked, what failed, and which approaches were fast enough for on-device use.

I saw the recent post about training 3D Gaussian Splats directly on an iPhone and realized we’ve been building something similar in Voxelio, using almost the same stack:

• SwiftUI and ARKit for capture
• msplat for on-device 3DGS training
• MetalSplatter for real-time rendering
• XcodeGen for the iOS project

The entire pipeline runs locally on the iPhone and already works surprisingly well for smaller scenes.

Before training, Voxelio refines the original ARKit camera poses using feature matching, Ceres bundle adjustment, and LiDAR depth. We also tested a few lighter pose-refinement approaches, but they were less stable in low-texture areas and more sensitive to incorrect matches. The current setup has been the most reliable so far.

I’d still like to reduce the BA processing time and improve its quality validation. Has anyone tried a particularly fast and reliable BA implementation for on-device iPhone captures? I’m especially interested in lightweight sparse or sliding-window approaches that work well with ARKit poses and LiDAR depth.

The video shows the current Voxelio test build.