Loomin

Where Productivity Peaks. Turning boring notes and lectures into interactive real time 3d simulations.

Comment

Inspiration

Loomin came from a realization that felt almost uncomfortable. We now have absurdly powerful AI tools like OpenNote, Gemini, and Groq that can generate notes, summarize lectures, and reason at incredible speed, yet learning itself still feels stuck in the past. We are producing more text than ever, but understanding has not scaled with it. OpenNote showed us how fast ideas can be captured and structured. Gemini showed us how machines can reason visually and interpret complex interfaces. Groq showed us what real time intelligence actually feels like. But none of these tools force ideas to be right. They help you explain. They help you write. They never make your understanding prove itself. That gap is what ignited Loomin. We realized the next leap in learning is not better explanations, it is execution. If you truly understand a system, that understanding should survive contact with reality. Numbers should move something. Assumptions should break visibly. Ideas should push back when they are wrong. Loomin exists to make that unavoidable. It turns AI generated notes into living systems and forces understanding to earn its place. Not another notebook. A proving ground for ideas.

What Loomin does

Loomin turns AI generated notes into executable reality. We use Feynman driven note generation to force clarity and first principles reasoning, and OpenNote style structuring to accelerate learning, but that is just the ignition. The moment notes appear in Loomin, they stop being text. They become configuration. The system parses what you wrote, extracts structure, converts it into parameters, and injects it directly into a live three dimensional physics simulation. Change a number and the system reacts instantly. The notebook stops being a document and becomes a control surface. This is visual reasoning embedded at the core of learning. Loomin is built on the belief that understanding that never has to survive execution is fake. If your intuition is wrong, the simulation exposes it immediately. This is the Feynman technique pushed to its absolute limit. You do not get to say you understand something. You have to make it work.

How we built it

Loomin is a real time full stack system engineered for speed, determinism, and scale. The frontend is a Next.js application that fuses a structured Monaco editor, media ingestion, and a live React Three Fiber simulation sandbox into a single workspace where writing and seeing are inseparable. Everything revolves around journals. Each journal is its own isolated execution environment, with its own notes, extracted parameters, media state, and simulation context. Zustand manages reactive state, localStorage persistence makes learning durable, and switching journals feels instant with zero context bleed. The backend is the intelligence layer. We use fast regex based parsing so simulations stay responsive while typing, and Groq powered inference when deeper semantic extraction is needed. Prisma with SQLite handles caching so repeated ideas do not waste compute, while rapid parameter changes always trigger fresh physics evaluation. Gemini is used as a visual reasoning and stability layer. It analyzes screenshots of the live interface to verify that simulations stay coherent with what the user is seeing, catching silent failures, UI desyncs, and visual regressions before they break trust. AI accelerates everything, but execution is always grounded and controlled.

Challenges we ran into

One of the hardest problems was reliability. Early versions would occasionally render the wrong simulation or fail to render anything at all, even when the notes were clear. This pushed us to reconsider how simulations themselves were chosen and coordinated, leading to a design where the simulation context is determined directly by the content and intent of the notes rather than by fragile inferred state. Another challenge was model quality. Because Loomin is meant for learning, a low-quality or unrealistic visualization actively harms the experience. We addressed this by building custom Three.js models that are highly parameterized and designed specifically to be modified dynamically rather than imported as static assets. Auto-fixing parameters was also more difficult than it initially sounded. Simply appending corrected values to the bottom of the notes quickly became unreadable. We had to build a robust system that locates existing parameters in multiple formats and edits them in place while clearly marking what changed. Caching introduced its own problems. While caching reduced API calls, it could also return stale results during rapid experimentation. Solving this required separating fast, always-fresh physics evaluation from slower, cached AI extraction.

Accomplishments that we're proud of

We built a notebook where writing is no longer inert. Watching someone change a single value in their notes and immediately see a physical system respond is game changing for the future of engineering. We turned failure into a core feature. When something breaks, Loomin explains why, edits the notes directly, and keeps the learner moving forward instead of stopping them cold. We also built a system where AI is powerful but constrained, fast but grounded, and never allowed to hallucinate unchecked. That balance is rare, and incredibly hard to get right.

What we learned

We learned that learning is driven by feedback loops, not explanations. When notes, simulations, and evaluation live in the same environment, experimentation becomes instinctive instead of intimidating. We also learned that real time AI systems demand discipline. Determinism, explicit routing, and physics based constraints are the only way to make AI trustworthy when it is driving interactive experiences.

What's next for Loomin

We want to push Loomin into multi component simulations where entire systems interact and tradeoffs emerge naturally. We want deeper document ingestion with OCR, speech recognition, and video understanding so lectures become living models. Long term, Loomin becomes an engineering scratchpad where ideas are written, executed, broken, fixed, and truly understood in one continuous loop. Not better notes. Real understanding.

Built With

Share this project:

Updates