FreeCAD is a mature, open-source parametric 3D CAD application with a modular workbench architecture. The codebase reveals a well-structured monolithic desktop application written in C++ with extensive Python bindings. The core uses OpenCASCADE as its geometry kernel, Coin3D (Open Inventor) for 3D scene representation, and Qt for the GUI. The architecture separates the application logic (App) from the GUI (Gui), with a Base layer providing fundamental utilities (math, units, persistence, Python integration). Workbenches (PartDesign, Sketcher, Draft, Arch, FEM, CAM, Mesh, etc.) are implemented as loadable modules that extend the document-object model. The parametric engine supports expression-driven constraints, a full dependency graph with topological naming, and a sketcher solver for 2D constraints. The FEM workbench includes a solver framework supporting CalculiX, Elmer, and Z88. The CAM workbench provides CNC toolpath generation with post-processing. The codebase demonstrates strong engineering practices: comprehensive unit tests, CI/CD pipelines, modern CMake, C++17, and clean separation of concerns. With 31k+ stars and active development (last commit June 2026), it's a production-grade CAD system used by hobbyists and professionals alike.
The OpenCAL firmware is a Python application designed to control a Computed Axial Lithography (CAL) 3D printer running on a Raspberry Pi 5. It orchestrates hardware components including a stepper motor (via Pololu Tic T249 or similar), LED array, projector (using mpv), camera (using picamera2), LCD display, and rotary encoder. Users interact via a menu-driven LCD interface to select video files from a USB drive and initiate print jobs, during which the system coordinates motor rotation, LED illumination, video projection, and image capture. The application follows a modular architecture with clear separation of concerns: GUI logic in `gui/`, hardware abstraction in `hardware/`, and configuration management in `utils/`. The LCD GUI implements a state machine for menu navigation, while the hardware layer uses a strategy pattern to support multiple stepper motor drivers (Tic USB, step/dir, UART, and a mock for testing). Configuration is managed through typed dataclasses loaded from a JSON file, allowing easy adaptation to different hardware setups. Key strengths include the reusable stepper motor abstraction layer, which cleanly separates the control interface from driver-specific implementations, and the configuration system that provides a robust, typed interface to hardware parameters. The USB media handler offers a simple, self-contained utility for managing media files on removable storage. The system is actively maintained and targets the Raspberry Pi 5 platform with specific hardware dependencies.
OpenSCAD is a mature, script-based 3D CAD modeler. It provides a declarative language for defining solid geometry through Constructive Solid Geometry (CSG) operations, extrusions, and transformations. The application consists of a C++ core that parses the custom scripting language, builds an AST, and evaluates geometry using either the CGAL or Manifold library for boolean operations. Rendering is handled via OpenGL with both preview (OpenCSG) and final render modes. The GUI, built on Qt, includes a code editor with syntax highlighting, a 3D viewport, parameter customizer, and an integrated AI assistant for code generation. Exports to STL, OBJ, SVG, 3MF, PDF, and other formats. The codebase demonstrates strong engineering with clear module separation (core, geometry, glview, gui, io, utils), extensive regression tests, and reusable patterns such as visitors, builders, and self-contained geometry utilities.
PicoGK is a compact, open-source computational geometry kernel developed by LEAP 71 for engineering design and additive manufacturing. It provides a C# API over a high-performance native voxel engine (OpenVDB). The core abstraction is the Signed Distance Field (Voxels), supporting boolean operations, offsets, shells, lattice generation, implicit modeling, and meshing. It includes a robust 3D viewer, industry-standard IO (STL, VDB, CLI), and utilities for slicing and cross-section visualization. While primarily a library, its numerical core and debugging utilities carry a strong data-processing character.
This repository provides the complete design and firmware for the Smart Plant, an ESP32-S2 based IoT device for monitoring soil moisture, ambient temperature, humidity, and illuminance. The firmware, built on the ESPHome framework, publishes sensor data to Home Assistant via MQTT and displays it on a 2.9-inch ePaper screen. It employs a sophisticated deep-sleep architecture to achieve 40-50 days of battery life, with careful power management of sensors and MQTT connections. The architecture is centered around a highly modular ESPHome YAML configuration. The `examples/multi-device/packages/smart_plant_base.yaml` file serves as a reusable base package, enabling fleet management through YAML substitutions and overrides. This pattern allows users to deploy multiple devices with a shared core configuration, customizing only device-specific parameters like MQTT topics and sensor calibrations. The data flow is strictly sensor-to-cloud, with retained MQTT messages ensuring Home Assistant entities remain available during the device's deep sleep cycles. Beyond firmware, the repository encompasses the full hardware design. The PCB is designed in Autodesk Eagle, and the 3D-printable enclosure is provided in both FDM (STL) and SLA (STEP) formats, originating from CATIA. The project is accompanied by professional Sphinx documentation hosted on ReadTheDocs, including assembly guides, safety information, and programming instructions. Overall, this is a high-quality, production-ready IoT project. The ESPHome base package is a standout reusable component for anyone building battery-powered ESPHome sensors. The hardware designs are complete and manufacturable. While the documentation contains minor copy-paste errors (e.g., referencing 'Smart Powermeter') and mixed-language comments in the YAML configs, the core firmware architecture and hardware design are exceptionally well-executed.
Clarvis AI is a Docker-based orchestration system that combines OpenClaw, claw3d, and curaengine-slicer-api to create an AI-powered 3D printing assistant accessible via Telegram, Discord, or WhatsApp. Users can interact through natural language to generate 3D models from text/images, search existing models, slice them to G-code, and send them to compatible printers. The system features a two-service architecture: a gateway handling AI and chat integrations, and a slicer service providing REST API access to CuraEngine for model slicing. The setup process is automated via a comprehensive bash script that builds Docker images, runs interactive configuration wizards for both OpenClaw and claw3d components, and starts all services. A notable reusable component is the Node.js-based configuration script for claw3d, which uses @clack/prompts to create a polished terminal user interface for gathering settings and outputting JSON configuration. This script exemplifies strong CLI tool design with clear separation of concerns, error handling, and adaptability for reuse in other projects.
KIAUH (Klipper Installation And Update Helper) is a text-based user interface (TUI) and CLI tool for managing the Klipper 3D printer firmware ecosystem. It automates installation, update, removal, and backup of core components (Klipper, Moonraker, Mainsail, Fluidd, KlipperScreen, Crowsnest) and a wide range of community extensions (OctoPrint, Telegram Bot, Obico, Spoolman, etc.). The tool runs on Linux systems (primarily Raspberry Pi and similar SBCs) and handles systemd services, Python virtual environments, git repositories, nginx configuration, and system package management. Architecturally, KIAUH is a Python package with a modular design: a core framework provides menu navigation, logging, spinner animations, and a backend abstraction layer for command execution and filesystem operations. Components and extensions are implemented as classes inheriting from BaseExtension, each with install/update/remove methods. The tool supports multiple printer instances via an InstanceManager and uses a custom SimpleConfigParser for round-trip safe manipulation of Klipper-style configuration files. A headless CLI mode enables scripted, non-interactive operation. The codebase demonstrates solid engineering practices: dependency injection for testability, a plugin architecture for extensions, extensive test coverage (pytest with fake backends), and a well-organized package structure. Key reusable assets include the SimpleConfigParser (a standalone, comment-preserving config parser), the backend abstraction (enabling deterministic testing), and the BaseExtension plugin interface. While the tool is actively maintained and widely used, some areas show technical debt such as singleton proliferation, direct subprocess calls in places, and a Python 3.8 baseline that may limit future compatibility.
This repository contains the complete design files, firmware, and assembly instructions for the Redox ergonomic split mechanical keyboard. It is not a software application in the traditional sense but rather an open-source hardware project delivering PCB Gerber/KiCad files, 3D-printable case STLs, precompiled QMK firmware hex files, and detailed build guides for both wired (Rev1.0) and wireless (Rev1.0W, Rev2.0WHS) variants. The code aspect consists of firmware configuration and custom KiCad footprints for keyboard components. The repository serves as a distribution hub for makers to manufacture their own Redox keyboard, with instructions for flashing via avrdude, ST-Link/Docker, and supports multiple firmware ecosystems (QMK, ZMK, KMK). The primary value is in the hardware design and documentation, not in runtime software.
lib3mf is a production-grade C++ library that implements the 3D Manufacturing Format (3MF) standard, providing read, write, validation, and conversion capabilities for 3MF files. It supports the full 3MF specification including mesh objects, beam lattices, textures, materials, colors, slice stacks, volumetric data, implicit modeling via computation node graphs, and encryption (key store, AES-GCM, RSA-OAEP). The library is cross-platform (Windows, Linux, macOS) and exposes a C++ API with auto-generated bindings for Java, Python, C#, Go, and NodeJS via the Automatic Component Toolkit (ACT). Architecture is layered: platform abstraction (streams, XML readers/writers), OPC (Open Packaging Conventions) ZIP-based package handling, version-specific XML readers/writers (v093, v100, extensions), in-memory model classes, and a public API wrapper. Key entry points are CModelReader_3MF_Native for reading and CModelWriter_3MF for writing. External dependencies include libzip (ZIP), zlib (compression), libressl (encryption), fast_float (float parsing), and cpp-base64. The codebase is well-structured with extensive use of design patterns (factory, decorator, iterator, reader node hierarchy) and includes a comprehensive test suite using Google Test.
Plater is a 3D printer parts placer and optimizer that takes STL files and configuration parameters to generate optimized print plates. It uses a heuristic based on greedy algorithm with brute force to arrange parts on print plates, minimizing the number of plates needed. The system features both a Qt-based GUI for interactive use and a command-line interface for automation. The architecture cleanly separates the core placement algorithm (in the plater/ library) from the user interface (in gui/), with the core library handling STL parsing, bitmap-based part representation, and the optimization algorithm. The placement algorithm pixelizes parts into bitmaps, applies spacing through dilation, and uses a gravity-inspired scoring system to position parts, running multiple iterations with different parameters to find the optimal solution.
This repository contains the hardware design files, CAD models (F3D, STEP, STL), and comprehensive documentation for the ERCF v2 (Enraged Rabbit Carrot Feeder version 2), a multi-material filament changer for 3D printers, primarily the Voron ecosystem. It is not a software application in the traditional sense—there is no executable code beyond configuration and scripting guides for Klipper firmware (Happy Hare plugin). The repo provides stl files for printing mechanical parts, CAD source files for modification, detailed assembly manuals (PDF), and step-by-step tutorials for hardware calibration, Klipper installation, and slicer setup. It also includes recommended optional add-ons (buffer, filament cutter, rewinder) and user-contributed modifications. The project is well-structured with clear directory layouts and extensive community support, evidenced by high stars and active issue tracking.
gcode-preview is a TypeScript library for rendering 3D-print toolpath previews from G-code files in web applications. It parses G-code command streams, interprets motion and extrusion commands, organizes the resulting paths into layers and tool segments, and renders them as either flat colored lines or volumetric tubes using Three.js. The library is structured as a pipeline of independently testable modules: a line-oriented parser, a stateful interpreter, a job/path model, and a Three.js scene manager. A Vue 3 demo application is included to exercise the library, but the repository is fundamentally a reusable npm package with ESM and UMD builds, unit tests, Firebase-hosted demo infrastructure, and publishing CI.
This repository is an open-source hardware reference design for the Framework Laptop 13, containing 3D CAD models (STEP, STL, DXF), 2D mechanical drawings, partial schematics, pinout tables, and 3D-printable case files. It is not a software application or data research project; it is a collection of design files enabling repair, customization, and third-party accessory development. The repository is organized by subsystem (mainboard, display, battery, hinges, touchpad, webcam, etc.) with detailed README documentation. The only software component is a GitHub Actions workflow for CLA compliance. The repository demonstrates high craftsmanship in hardware documentation with standardized pinout tables and modular printable case designs. It is actively maintained with recent commits and an active issue tracker.
Strecs3D is a specialized desktop application designed to optimize 3D printing infill density through Finite Element Method (FEM) analysis. The software ingests CAD geometry (STEP/STL) and optional stress analysis results (VTU), segments the mesh based on stress thresholds, and exports variable-density 3MF files compatible with major slicers like Cura, Bambu Studio, and PrusaSlicer. It serves as a bridge between structural engineering simulation and additive manufacturing, allowing users to reduce material usage while maintaining structural integrity. The architecture is built on Qt 6 for the user interface and VTK for 3D visualization, compiled via CMake with vcpkg for dependency management. The application follows a modular design with a clear separation between the UI layer, core processing logic, and FEM pipeline integration. It supports a full simulation workflow, converting STEP files to CalculiX input (INP), running the solver, and converting the output (FRD) back to VTK format for visualization and processing. Data flows from geometry import through optional FEM simulation to mesh segmentation and 3MF export. The system relies heavily on external tools (CalculiX, Gmsh, OpenCASCADE) which are integrated via custom ports and wrappers. While the internal C++ code demonstrates professional engineering practices, the heavy coupling to external binary dependencies and platform-specific build configurations introduces maintenance complexity. The codebase is actively maintained with recent commits and a low issue count relative to its popularity. However, technical drift is present due to hardcoded paths for external solvers and custom patches for Gmsh, which require careful version management to prevent breakage in deployment environments.
This repository is the mechanical and electronics design for a DIY sim racing force feedback pedal. It contains CAD models (Fusion 360, STEP, STL) for 3D-printed and machined parts, detailed soldering guides for several PCB revisions, wiring diagrams, bill of materials, and investigations into key components (ADC, loadcell, brake resistor). The repo does NOT contain any application software, firmware, or data pipelines; it is purely a hardware design and assembly guide. The project is well-documented with multiple design iterations and clear instructions for building a custom FFB pedal using a servo motor, linear rail, loadcell, and ESP32-based control electronics.
TouchTerrain is a web application and standalone tool that converts digital elevation models (DEMs) into 3D-printable terrain models (STL/OBJ). It uses Google Earth Engine as the primary DEM source, with support for local GeoTIFF files. The architecture includes a Flask web server with a frontend using Google Maps and Three.js for preview, a standalone Python script for batch processing, and Jupyter notebooks for interactive use. The core processing pipeline fetches DEM data, resamples it, tiles it, generates mesh geometry with optional walls and bottom, and bundles the output as a ZIP file. The repository also includes geospatial utilities (coordinate conversion, KML parsing, GPX path embossing) and raster cleaning functions. While the codebase is functional and well-documented, it shows signs of technical drift: multiprocessing is broken, JavaScript libraries are outdated (Three.js r71), and there is commented-out code. The project is actively maintained with recent commits and issue triage.
This repository contains the open-source hardware design files for the 'dumbpad', a customizable 4x4 mechanical macropad with support for rotary encoders, OLED displays, and RGB LEDs. It is a hardware design repository, not a software application. The repo includes multiple PCB variants (Eagle and KiCad formats) with different features: through-hole switches, hotswap sockets, low-profile Gateron switches, per-key RGB, and OLED displays. Also included are 3D-printable case designs (STL and SketchUp files), Gerber manufacturing files, and VIA configuration JSON. The designs are modular, with reusable KiCad footprints and a standard keyboard matrix pattern. The project is actively maintained with several community-contributed variants. No firmware source code is present; the macropad is intended to run QMK firmware, which is maintained separately.
MatterControl is a comprehensive, open-source desktop application for controlling and enhancing 3D printing workflows. It integrates slicing, printer management, 3D model design and editing, library management, and G-code streaming into a single GUI built on the MatterHackers Agg framework. The codebase is large (2000+ files) and spans multiple subprojects: printer communication (serial, TCP/IP, X3G), slicing engines (MatterSlice, gsSlicer, SLA), 3D design tools (primitives, boolean operations, path editing), and a plugin system. The architecture follows a monolithic desktop application pattern with heavy use of custom UI widgets and a decorator-based G-code processing pipeline. While feature-rich and historically active, the project shows signs of technical drift: reliance on an older .NET Framework (4.7.2), a bundled port of SQLite (Community.CsharpSqlite), and numerous obsolete or versioned classes (e.g., `MirrorObject3D` → `MirrorObject3D_2`). The codebase contains many reusable patterns (e.g., GCodeStream decorators, UIField hierarchy, plugin system) but extraction would require significant effort due to tight coupling with the MatterControl domain model.