Plumber is a Blender addon for importing Source 1 engine game assets (maps, models, materials, textures) into Blender. It features a hybrid Python/Rust architecture where Python handles Blender integration and UI, while Rust performs performance-critical asset parsing and processing. The addon automatically detects installed Source games on Steam and provides both interactive import operators and a programmatic API for batch processing. Notable for its elegant material node system that cleanly converts Source engine materials to Blender-compatible node materials using a builder pattern with automatic dependency resolution.
This is a Blender add-on for renaming various types of data in 3D scenes, including objects, materials, bones, collections, and other data blocks. It provides a comprehensive set of renaming tools accessible through Blender's interface, allowing users to add prefixes/suffixes, perform search and replace operations, transform text case, apply sequential numbering, and trim strings from names. The add-on features a variable system that enables dynamic naming patterns using placeholders like @n for numbers, @f for the current filename, @d for date, and others. It includes intelligent conflict handling that detects when Blender would automatically modify a requested name due to existing duplicates, and either skips the renaming or finds an alternative name rather than accepting Blender's default behavior which could cause confusion in batch operations. Architecturally, the add-on follows Blender's standard extension structure with clearly separated modules for operators (the actual renaming functions), user interface components, preferences, and utilities. It employs performance optimizations such as caching collection membership and object ownership relationships to avoid repeated lookups during batch renaming operations. The tool provides real-time feedback through popup windows showing what was renamed, what was skipped due to conflicts, and any warnings. The project maintains active development with regular updates and testing across multiple Blender versions (from 4.2 to 5.1 as shown in CI workflows). It includes a comprehensive test suite that validates functionality and performance benchmarks to ensure operations scale efficiently with scene complexity. The combination of thoughtful design, attention to edge cases, and ongoing maintenance makes it a reliable tool for managing naming conventions in Blender projects.
FLIP Fluids is a production-grade Blender addon for liquid simulation, integrating a custom C++ FLIP (Fluid Implicit Particle) engine with a comprehensive Python UI. The engine implements advanced numerical methods including level sets, variational pressure solvers, PCG with MIC(0) preconditioning, force fields, whitewater particles, and viscosity solvers, all backed by a vendored Eigen linear algebra library. The Blender addon provides property groups, UI panels, preset management, material libraries, and command-line scripts for baking, rendering, and Alembic/USD export. The architecture is a hybrid: the C++ engine is compiled as a shared library and accessed via C bindings and Python ctypes wrappers, while the addon code follows standard Blender patterns (operators, panels, property groups). Key entry points include the baking operators, simulation domain properties, and the engine's Python bindings in `ffengine/`. External dependencies include Blender (4.5+), Eigen, and optionally Mixbox for color blending. The codebase is well-structured with extensive version compatibility layers, but the vendored Eigen and reliance on Blender's evolving API introduce moderate technical drift.
BQt is a Blender add-on that integrates PySide6 QtWidgets with Blender, allowing developers to create custom UIs for their add-ons using Qt. The system wraps Blender's native window in a Qt container, manages the Qt event loop alongside Blender's main loop, and provides widget management to ensure Qt widgets stay properly parented and visible relative to Blender windows. It handles platform-specific window management for Windows and macOS to maintain proper focus and activation behavior, including a native event filter that forwards WM_ACTIVATE events on Windows to prevent focus issues when multiple Blender windows are open. The architecture features a modular design with abstract base classes for platform-specific implementations, clean separation of concerns between widget management, application logic, and utilities, and follows Blender add-on conventions.
This repository provides a high-performance surface reconstruction system for SPH (Smoothed Particle Hydrodynamics) fluid simulation data. The core library, splashsurf_lib, implements a marching cubes pipeline that converts particle positions and densities into triangle meshes, with subdomain-based parallel decomposition, SIMD-accelerated kernel evaluation (AVX2, NEON), and optional post-processing (weighted Laplacian smoothing, barnacle decimation, quad conversion, attribute interpolation). The system is exposed as a CLI tool (splashsurf), a Python package (pysplashsurf via PyO3), and a Blender add-on (splashsurf_studio) for interactive viewport and render-time reconstruction. The architecture is modular: a generic library with traits for numeric types, a dense subdomain grid for parallelism, a half-edge mesh for decimation, and a custom nom-based BGEO parser. The codebase is well-structured with strong emphasis on performance and reproducibility, and it implements the research from Löschner et al. (2023) on weighted Laplacian smoothing. It targets researchers and artists working with SPH simulations (e.g., SPlisHSPlasH) and supports multiple input/output formats (VTK, PLY, OBJ, BGEO, XYZ, JSON).
wow.export is a desktop application for extracting, previewing, and exporting assets from World of Warcraft (Retail, Classic, and other versions). It reads game data from local installations (CASC and MPQ archives) or remote CDN servers, parsing proprietary formats including M2 models, WMO world objects, ADT terrain tiles, BLP textures, DB2/WDC data tables, and audio/video files. The application provides a tabbed UI for browsing and exporting assets to standard formats such as OBJ, GLTF, STL, PNG, WebP, CSV, and SQL. It includes a real-time 3D preview powered by WebGL2 with skeletal animation, skinning, and environment effects like fog and lighting. Architecturally, the application is a monolithic desktop client built with NW.js and Vue.js. The core data pipeline consists of archive readers (CASC and MPQ), format parsers/loaders, and export writers. A module system registers tabs and context menus, and a central event bus coordinates state. WebGL rendering is abstracted through a set of helper classes (GLContext, VertexArray, ShaderProgram) used by multiple renderers for M2, WMO, terrain, and liquids. The application relies on Node.js built-ins for file I/O and binary data handling, and uses native addons (mmap) for efficient access to large listfiles. Key entry points include src/app.js (application bootstrap), src/js/core.js (central state and events), src/js/modules/tab_home.js and other tab modules, and the various loaders and exporters in src/js/3D/. External dependencies include NW.js, Vue.js, and a few npm packages like adm-zip and webp-wasm. The application is actively maintained with frequent updates to support new WoW patches and export features. Notable reusable components include BufferWrapper (binary read/write with BLTE support), WDCReader (generic DB2/WDC file parser), and GLTFWriter (glTF binary exporter). These modules are isolated and could be extracted for other projects dealing with binary formats or 3D asset pipelines.
This repository implements an end-to-end 3D object generation application that takes natural language descriptions and produces 3D mesh models (GLB format). It orchestrates three generative AI models: an LLM (Qwen3 or Llama) for scene planning, a diffusion model (SANA Sprint) for 2D image generation, and Microsoft TRELLIS for 3D generation. The system presents a Gradio web interface for user interaction and includes a Blender addon for direct import of generated assets. It supports two deployment modes: native PyTorch models (for local development) and NIM containers (for scalable inference). Key architectural patterns include a singleton GPU memory manager that coordinates model loading/unloading across VRAM-constrained GPUs, a guardrail service for content safety, and a conditional service abstraction that transparently switches between native and NIM backends based on configuration. The repository is well-structured with modular UI components and comprehensive installation scripts, though it is Windows-only and has complex event chains in the main UI file. The code is actively maintained with recent commits and pinned dependencies, but the heavy reliance on patched versions of TRELLIS and a specific Gradio version introduces some maintenance risk.
This repository contains the source code for the Poseidon game engine, which powers the remastered version of Arma: Cold War Assault (CWR). It is a large, monolithic C++20 codebase with a modular subsystem architecture covering graphics (OpenGL 3.3), audio (OpenAL), networking (UDP with custom transport), input (SDL), AI, world simulation, UI, and asset management. The engine supports dedicated servers, modding via PBO archives, and a scripting language (SQF/SQS). The repository also includes a suite of CLI tools (PBO packing, image conversion, model inspection, etc.), a Blender addon for importing P3D models, and Rust components for a master server and test harness (Trident). Extensive unit tests (Catch2) and fuzz harnesses are provided. The codebase is a locked snapshot with no active development, but it demonstrates high craftsmanship in areas like custom containers, memory management, and network protocol design. However, it suffers from technical debt including heavy use of preprocessor macros, global state, and platform-specific conditionals.