F3D is a fast, minimalist 3D viewer and rendering library (libf3d) built on VTK, providing both a desktop application and a reusable C++ library with bindings for C, Python, Java, and WebAssembly. It loads and interactively visualizes dozens of 3D file formats (glTF, USD, STEP, STL, OBJ, FBX, etc.) through a plugin architecture. The application offers a rich CLI, interactive console, configurable rendering options, animations, and scientific visualization features like volume rendering, scalar coloring, and point clouds. The library exposes a clean public API (engine, scene, window, camera, interactor, options) that can be embedded in other applications or used for offscreen rendering. The codebase demonstrates strong engineering: modular plugin system, extensive test suite (including pixel comparison and event recording), cross-platform support, and thorough documentation. Its architecture separates concerns cleanly between application layer, library, VTK extensions, and plugins, making individual components potentially reusable in other VTK-based projects.
Generic Mapping Tools (GMT) is a mature, open-source collection of approximately 100 command-line tools for processing geographic and Cartesian data and producing high-quality PostScript illustrations, maps, and animations. The system is architected as a modular C library with a central dispatcher executable (`gmt`) that loads and runs individual modules. It supports both a classic mode (direct module calls) and a modern mode (`gmt begin/end`, `gmt subplot`) that manages sessions, figures, and panels. Key entry points include the `gmt` command, the C API (`GMT_Create_Session`, `GMT_Call_Module`), and shell completion scripts. Data flows involve reading grid, table, image, and color palette table (CPT) data from local files or remote servers (via `@` prefix), processing through modules (e.g., `grdimage`, `psxy`, `grdmath`, `grdfilter`), and outputting PostScript, grids, or other formats. External dependencies include netCDF, GDAL, FFTW, PCRE/POSIX regex, PROJ, GSHHG coastlines, and DCW country polygons. The codebase exhibits high craftsmanship with systematic option parsing, a well-defined API, extensive test coverage, and reusable infrastructure components.
FigMirror is a reference-conditioned scientific figure style transfer system that iteratively generates matplotlib scripts matching the visual style of a reference figure. It operates as a multi-agent loop (Drawer/Reviewer) orchestrated by a runner backend (Codex, Claude, or Mock), with a local web UI for upload, iteration browsing, and refinement. The system is packaged as skills for both Claude Code and Codex, plus a standalone web server. While primarily an application, it has a strong research component: the prompts, aesthetic library, and evaluation benchmarks (PlotTwin-Bench) are the result of extensive empirical iteration. The codebase demonstrates high craftsmanship in its runner architecture, atomic file operations, SSE streaming, and deterministic review gates. However, it suffers from dual skill bundles (Claude/Codex) that must stay synchronized, retired artifacts, and some incomplete features (ClaudeRunner, SSE integration).
The ANARI SDK is a comprehensive implementation of the Khronos ANARI (ANother API for Rendering and Imaging) standard, designed for scientific visualization rendering. It provides a core C/C++ frontend library, multiple device backends including a CPU reference renderer (helide using Embree), an experimental GPU backend (helide_gpu using SDL3 GPU), a remote rendering device over TCP, a debugging/serialization device, and a no-op sink device. The SDK also includes a Conformance Test Suite (CTS) for validating device correctness via image-based comparisons (SSIM/PSNR), a reusable base framework (Helium) that abstracts common device implementation patterns (parameter management, deferred commits, object lifecycle), code generation tools that produce C++ code from JSON extension definitions, and an OpenUSD Hydra render delegate plugin for integration with Pixar's USD ecosystem. Additionally, it ships example applications (viewer, capability analysis tool, Blender add-on) and a rich set of test scenes for performance and correctness testing.
Matplot++ is a C++ graphics library for data visualization that provides a MATLAB-like API for creating publication-quality plots. It supports a wide range of plot types including line, scatter, bar, histogram, surface, contour, polar, geographic, and 3D plots, as well as image display, graph visualization, and annotations. The library is designed for scientific computing and engineering applications, offering both free-standing function calls and an object-oriented interface with method chaining. It features a pluggable backend architecture with Gnuplot as the primary rendering backend (via pipe communication) and an experimental OpenGL backend. The library handles data transformation, automatic tick calculation, colormap interpolation, contour generation (adapted from Matplotlib), histogram binning with multiple algorithms, and geographic map rendering using bundled Natural Earth data. External dependencies include Gnuplot 5.2.6+ at runtime, with optional support for image processing libraries (CImg, JPEG, TIFF, PNG, OpenCV) and numerical libraries (FFTW, LAPACK, BLAS). The build system is CMake-based with comprehensive options for testing, examples, and documentation generation. Architecturally, the library is organized around a core figure-axes-object hierarchy: figure_type manages the canvas and backend, axes_type holds plot objects and axis configuration, and individual plot types (line, bars, histogram, etc.) inherit from axes_object and implement backend-specific rendering methods. Free-standing functions in freestanding/ forward calls to the current axes via a global figure registry. The backend interface abstracts rendering commands, allowing the same plot objects to work with different backends. The library includes a large set of examples (200+) that serve as both documentation and integration tests, and a documentation pipeline that auto-generates a gallery from example executables. Key entry points for users are the matplot.h header and the free-standing functions (plot, hist, surf, etc.). The library is consumed via CMake's find_package or as a subdirectory. It supports both interactive (reactive) and non-interactive (quiet) modes, and can save plots in multiple formats (SVG, EPS, PNG, PDF, etc.) through backend-specific commands.
This repository is a curated collection of 177+ domain-specific scientific 'skills' for AI agents, following the Agent Skills standard. Each skill is a self-contained module providing a CLI tool, documentation, and tests for a specific scientific or technical task—ranging from single-cell RNA-seq analysis (scanpy) and molecular docking (diffdock) to clinical report validation and ISO standards readiness. The architecture is a monorepo of independent skills, each with its own scripts/, references/, assets/, and tests/. Skills are designed to be safe, bounded, and reproducible: they validate inputs before execution, enforce resource limits, avoid network access unless explicitly required, and produce structured JSON reports. The repository also includes a shared test infrastructure (skill_contract) and a meta-skill (autoskill) that can automatically propose new skills from screen activity. While primarily an application library for AI agents, it has strong data/research characteristics due to its heavy use of scientific data formats and validation of research artifacts.