This open-source pipeline converts iPhone LiDAR scans into editable Three.js browser scenes using an AI coding skill, yet remains a fragmented, iterative prototype rather than a turnkey product. Its tension lies in bridging high-friction manual reconstruction with the promise of accessible web-based 3D visualization.
The short version
- What it is: It is a source-available iOS app, Three.js viewer, and AI agent skill that reconstructs interior spaces from LiDAR and photos.
- Why it matters: It matters because it enables non-experts to explore browser-based 3D interiors without enterprise software, leveraging widely available iPhone hardware.
- Main risk: The main risk is that the workflow is explicitly iterative and manual, requiring local iOS builds and complex Python dependencies, which creates a high barrier to entry.
What it actually does
The repository provides an iPhone app for capturing LiDAR and photo evidence of rooms, a Node.js-based Three.js viewer for exploring reconstructed scenes in dollhouse, walking, overhead, wireframe, and knolling modes, and an AI agent skill that guides the reconstruction process. The skill instructs an agent to inspect measurements and photos, create an editable scene, and compare rendered views with original photographs. The system supports Python 3 helpers for photo comparisons and optional depth reconstruction using NumPy and Open3D. Only a specific office demo is distributed, while original scan bundles are excluded to protect privacy. Users must build the iOS app locally from source, as an App Store release is not currently available, and extract exports to a designated directory to feed into the agent workflow.
Why it could matter
This project addresses a significant gap in personal 3D visualization by leveraging widely available iPhone LiDAR hardware to create editable web-based scenes. By shifting the processing pipeline to browser-based Three.js, it reduces the installation barriers associated with traditional desktop-centric CAD or photogrammetry software. The integration of an AI coding agent as the reconstruction guide offers a scalable path for non-experts, such as designers and developers, to visualize their spaces without deep 3D modeling expertise. If the friction of the current manual workflow is reduced, this could democratize access to interior spatial data, enabling richer digital twins of personal environments for applications ranging from home design to remote collaboration, all within a standard web browser context.
The case against it
Three concrete risks undermine immediate utility. First, the workflow is explicitly iterative and manual, requiring users to manage Python dependencies and configure AI agents, which creates a high barrier to entry for casual users. Second, the system is fragmented across three distinct components: an iOS app that must be built locally from source, a Node.js viewer, and an AI skill, meaning no single turnkey solution exists. Third, the lack of an App Store release forces users to handle complex local builds and extraction processes, creating significant friction between the capture device and the processing pipeline. Additionally, the project is limited to rooms and interiors, and the reliance on specific hardware like LiDAR-equipped iPhones restricts the potential user base compared to more universal capture methods.
Business and cost
The project operates within a low-budget scope typical of a solo developer, with core code licensed under MIT, eliminating licensing fees for the reusable source and skill. The primary costs are developer time and basic infrastructure for hosting the demo. Required tools, including Python 3, Node.js 22, and libraries like Pillow and Open3D, are free open-source technologies. No cloud services or paid AI APIs are stated for the core workflow. Since the iOS app is source-available and requires local building, no App Store listing fees are currently incurred. However, the source does not state a revenue model, subscription pricing, or any commercial distribution plans, leaving the long-term financial sustainability of maintaining this fragmented, multi-platform toolchain undefined and dependent on community adoption rather than direct monetization.
Historical pattern
This project aligns with historical patterns of consumer AR/VR capture tools that struggled with the final processing stage. Similar to early photogrammetry attempts, the reliance on manual iteration and specialized agents mirrors the complexity historically seen in professional CAD software. However, the shift toward browser-based visualization using Three.js follows a favorable trend in web technologies, reducing installation barriers compared to desktop-centric predecessors. The use of LiDAR echoes the hardware trend from Apple’s initial LiDAR-equipped devices, which initially saw limited adoption but now has a solid user base. The open-source licensing of code, coupled with separate asset licensing, follows standard modern web development distribution models, balancing utility with intellectual property protection for commercial assets, a pattern that has been effective in maintaining community trust while protecting proprietary elements.
The call
The verdict is cautious optimism, as the project demonstrates a viable, iterative workflow but lacks the polish for mass adoption. A realistic timeline for significant impact is 12 to 18 months, contingent on stabilizing the iOS app for public distribution and simplifying agent integration. The verdict would change to strong positive if the team releases an App Store build, automates the measurement phase to reduce manual dependency, and documents Python helper requirements more clearly. Conversely, the project will remain a niche developer tool if it fails to bridge the gap between the fragmented capture and processing steps, leaving the barrier to entry too high for non-technical users. Continued focus on interior-specific use cases without expanding hardware compatibility will likely limit its broader spatial exploration utility.
Scorecard
| Role | Score |
|---|---|
| Advisor | 7.0 |
| Devil | -4.0 |
| Historian | 2.0 |
| Budget Steward | 1.0 |
| Founder | 6.0 |
| Overall | 4.6 / 10 |
CRP review record
Advisor
The project leverages widely available iPhone LiDAR hardware to bridge a significant gap in personal 3D visualization. By converting spatial data into editable Three.js scenes via an AI-driven skill, it enables users to explore interiors in the browser without heavy enterprise software. The inclusion of distinct views like dollhouse and wireframe adds immediate utility. While currently limited to rooms and interiors, the foundation supports broader spatial exploration use cases. The integration of an AI coding agent to guide reconstruction offers a scalable path for non-experts to visualize their spaces. This positions the tool as a valuable resource for designers, developers, and curious individuals seeking accessible 3D room modeling.
Devil
Several critical risks limit immediate utility. First, the workflow is explicitly iterative and manual, not one-click, requiring users to handle Python dependencies and AI agent configuration, which creates a high barrier to entry. Second, the project is fragmented across three distinct systems: an iOS app, a Node.js viewer, and an AI skill, meaning no single turnkey solution exists. Third, the source states that an App Store release is a "separate distribution step" and not yet available, forcing users to build the iOS app locally from source. This disconnect between the capture device and the processing pipeline creates significant friction for casual users who expect a seamless mobile-to-web experience.
Historian
This project aligns with historical patterns of consumer AR/VR capture tools that struggled with the "last mile" of processing. Similar to early photogrammetry attempts, the reliance on manual iteration and specialized agents mirrors the complexity seen in professional CAD software. However, the shift toward browser-based visualization (Three.js) follows a favorable trend in web technologies, reducing installation barriers compared to desktop-centric predecessors. The use of LiDAR echoes the hardware trend from Apple’s initial LiDAR-equipped devices, which initially saw limited adoption but now has a solid user base. The open-source licensing of code, coupled with separate asset licensing, follows standard modern web development distribution models, balancing utility with intellectual property protection for commercial assets.
Budget Steward
The project operates within a low-budget scope for a solo developer. The code is MIT-licensed, eliminating licensing fees. The primary costs are developer time and basic infrastructure for hosting the demo, which are minimal. The requirements for Python 3, Node.js 22, and specific Python libraries (Pillow, NumPy, Open3D) are free open-source tools. No cloud services or paid AI APIs are mentioned in the source for the core workflow. Since the iOS app is source-available and requires local building, there are no App Store listing fees currently incurred. The absence of stated paid dependencies or complex backend infrastructure suggests that maintenance and development can be handled within a small personal or small team budget without significant financial outlay.
Founder
The decision to build this project is justified by its demonstration of a viable, iterative workflow for 3D room reconstruction. The timeline should focus on stabilizing the iOS app for public distribution and simplifying the agent integration to reduce user friction. While the current state is a strong prototype with an office demo, the strategic value lies in the "scan-to-threejs" skill which encapsulates the reconstruction logic. We should proceed with building this by prioritizing the documentation of the Python helper requirements and the iOS app build process. The goal is to make the iterative process more transparent and potentially introduce lightweight automation for the measurement phase. This validates the concept before scaling to more complex spatial environments.