3D Generative AI

A deep dive into the Geometric Context Transformer, the memory tricks that keep long video streams stable, and why this repo feels less like SLAM software and more like a geometric operating system.

How a Flow-Matching Diffusion Transformer and parallel data streams turned days of manual 3D modeling and UV mapping into a sub-10-second inference step.

A deep dive into the flat scene store, dirty-node update loop, and WebGPU-ready architecture that make real-time architectural editing work in the browser.

A close look at the code that rails prompt generation, uses Clerk metadata as lightweight state, and makes FLUX feel like a focused branding tool instead of a blank canvas.

A reverse-engineered template library that treats GPT Image 2 like a structured rendering engine, with JSON schemas, anti-pitfall rules, and gallery cases that behave like tests.

A Next.js app that turns a general image model into a focused branding tool by narrowing the prompt, limiting the UI, and pushing heavy usage onto user-owned API keys.

Instead of repainting the whole image, this Codex Skill preserves the original photo and builds a disciplined abstract companion panel from its spatial facts, palette, and rhythm.

How an open-source project uses WebAssembly and a decades-old C++ engine to turn language models into parametric 3D designers.

A deep dive into the OpenMMLab toolbox that turns video understanding into reusable configs, hooks, and task modules.

How PlayCanvas built a web-native 3DGS tool that handles selection, cleanup, sorting, and export by treating splat state as GPU data, not expensive mesh edits.

A browser proposal that lets real DOM content participate in layout, hit-testing, and accessibility, then get drawn into 2D and 3D rendering pipelines as a native primitive.

How Meta AI and Oxford rebuilt feed-forward 3D reconstruction around compact memory, multi-task heads, and a geometry-first Transformer that scales beyond classic SfM.

A 3D successor to Box2D that swaps raw pointers for IDs, rewrites math for repeatability, and uses soft stepping to keep stacks, joints, and large worlds from falling apart.

How a Python framework rejected fluent APIs and embraced operator overloading to turn physical manufacturing into a standard software pipeline.

A browser shooter built with Three.js, WebGL2, and zero external assets, where the bigger story is the agent workflow, the procedural pipeline, and the ruthless regression testing that keeps it all standing.

A provider-agnostic workbench that generates, caches, scores, and stages 3D assets with the kind of workflow discipline most image-to-3D tools skip.

How a two-decade-old C++ engine uses mathematical tweening and custom smart pointers to automate the labor of 2D animation.

How thebuggeddev/anatomy turns AI-generated assets, Three.js, and Cloudflare-native delivery into a polished medical learning tool that behaves like a gallery, not a static textbook.

How a two-pass diffusion system, a vision-language reasoner, and counterfactual training data turn video inpainting into causal scene rewriting.

How Robbyant turns video generation into a live simulation with causal attention, KV-cache sinks, and real-time control.

How a massive C-API orchestrates the shift from traditional rasterization to hardware-accelerated neural rendering.

How a PyTorch-backed CUDA pipeline, tile sorting, and differentiable splatting turned a point cloud of anisotropic Gaussians into a real-time graphics primitive.

A zero-dependency pipeline turns a single image into procedural Three.js factories, so AI agents can rebuild, inspect, and refine 3D objects as source code instead of opaque meshes.

A look at the sidecar architecture, extension protocol, and GPU-native post-processing that make image-to-mesh generation feel like a real product instead of a research demo.

A look at NVIDIA’s self-distillation pipeline, where imagined camera moves become Gaussian splats, and splats become real-time explorable scenes.

A Codex plugin that rebuilds reference images as procedural Three.js factories by forcing the model through blockout, validation, and refinement passes instead of a one-shot mesh dump.

A look at the memory bank, distilled inference, and audio-visual anchoring system that lets a single prompt grow into a coherent multi-shot sequence.

A zero-build WebGL scene uses atmospheric scattering, procedural bird motion, and tiled ocean tricks to turn physics into serenity.

An opinionated, local-first CAD environment turns natural language into parametric solids, then pushes the model through printability checks, real geometry, and iterative repair.

How MiniMax-AI moved beyond pixel-perfect reconstruction to unlock the scaling laws of visual tokenization.

A deep dive into the ComfyUI wrapper that turns TRELLIS.2 into a practical image-to-mesh pipeline, with sparse tokens, flow matching, custom CUDA, and enough memory discipline to run like a real tool.

By discarding the GPU in favor of a custom polygon clipping engine, this zero-dependency library brings architectural voxel art to pen plotters and generative designers.

How MiniMax-AI unified perception and reasoning into a single RL pipeline using Dynamic IoU rewards.

Instead of one merge ratio, this extension gives you 25. That turns model merging from a guess into a controlled design process.

A geometry-aware system for recovering camera pose, synthesizing consistent novel views, and lifting them into Gaussian splats for simulation.

How a specialized Python stack is turning NASA’s hyperspectral firehose into an interactive, browser-based laboratory for coastal science.

A deep dive into how hierarchical masking, token merging, and custom CUDA kernels let a point-cloud model learn shape efficiently without flattening geometry into a plain transformer.

A deep dive into the open-source framework that pairs synthetic geometry, a VLM-guided diffusion model, and a benchmark built to measure spatial fidelity instead of just visual plausibility.

How Cheng Lou turned the browser's layout engine into a GPU, bypassed GitHub's Markdown filters, and built a zero-JavaScript shader using pure CSS.

A Python library that turns standards tables, fasteners, bearings, and threads into parametric solids, then reaches beneath CadQuery to patch in the missing industrial stuff.

How a Next.js component uses runtime script injection and hidden 2D canvases to deliver high-end WebGL shaders without touching your package.json.

How a USD-based standard turns 3D assets into simulation-ready contracts, catches physics bugs before runtime, and tries to end the chaos of incompatible units, joints, and runtimes.

A clean-room tool that parses Bungie's packages, interprets Tiger Engine shader logic, and reassembles the frame for study.

Inside the smartphone-video pipeline that decides whether the camera moved, whether the person is on a treadmill, and how to stop feet from skating before exporting OpenSim-ready motion files.

A binary-first archive for artists and archivists, built to surface unreleased game data without normalizing spoilers, panic, or copycat leak culture.

A reference app that turns long-running video generation into a usable workflow with prompt optimization, starter images, polling, local persistence, and remix forks.

Sakana AI's PD-NCA turns growth into an ecosystem, where multiple learners fight, adapt, and survive inside one shared dish.

A look at the WebGL2 pipeline, Draft Pose workflow, and stencil-buffer tricks behind a new kind of animation tool for layered art.