EldoraUI is a modern, open-source React/Next.js component library distributed via a shadcn/ui-style registry. It provides over 40 animated UI components, including text animations, device mockups, 3D globes, interactive cards, and full-page blocks (headers, CTAs, pricing tables, testimonials). The repository is a monorepo with a Next.js documentation site that showcases each component with live previews, code examples, and MDX-based guides. Components are designed for copy-paste installation via CLI (`npx shadcn add`) and rely on Tailwind CSS, Motion (Framer Motion), Three.js, and Radix UI primitives. The library targets 'design engineers' building modern, animated interfaces. While the codebase is actively maintained and demonstrates strong craftsmanship in several complex components (e.g., Browser, CobeGlobe, TextAnimate), it exhibits some technical drift: pervasive typos in block names ('testimonal'), fragile DOM coupling in the table of contents, outdated TODO comments, and potential registry duplication. Overall, it is a solid, production-quality component library with high reusability.
SkinTokens is a research codebase for a novel 3D character rigging method (TokenRig) that learns a compact discrete representation (SkinTokens) for skinning weights. The system ingests 3D meshes with skeleton and skinning data (from ArticulationXL, VRoid Hub, ModelsResource), transforms them through a pipeline of augmentation, order arrangement, vertex group extraction, and sampling, then trains an FSQ-CVAE to compress skinning weights into discrete tokens. A Qwen3-0.6B-based autoregressive transformer (TokenRig) generates the full rig (skeleton hierarchy + skin tokens) as a single token sequence. The repo includes a Blender-based server for mesh loading and export, a Gradio demo, a CLI, and extensive data processing modules. The code is well-structured with dataclass-based configs, abstract interfaces, and modular design, but remains primarily a research artifact with some incomplete training implementations (e.g., TokenRig training_step raises NotImplementedError). Its hybrid nature leans strongly toward data research, as the core contribution is a learned representation and generative model for animation rigging.
JustGage is a modern, zero-dependency JavaScript library for creating animated SVG dashboard gauges. It is a complete rewrite of the legacy RaphaelJS-based v1.x, using native SVG APIs and ES6+ class-based architecture. The library provides a highly customizable gauge with support for donut, differential, pointer, target lines, custom sectors, and multiple animation easing functions. The source is organized into modular components: core gauge logic (`src/core/JustGage.js`), configuration handling (`src/core/config.js`), a requestAnimationFrame-based animator (`src/core/GaugeAnimator.js`), a native SVG renderer with a Raphael-like wrapper (`src/rendering/svg.js`), and utility modules for colors, formatting, DOM, and general helpers. The build system uses esbuild to produce ESM, CJS, and UMD outputs, and tests are run with the Node.js native test runner and jsdom. The codebase demonstrates good engineering practices: separation of concerns, comprehensive test coverage (unit, integration, edge cases), and CI/CD pipelines. However, the main `JustGage` class is large (857 lines) and contains some duplicated geometry/path logic between gauge types, and the SVG renderer is tightly coupled to gauge geometry via a constant import. Overall, it is a well-crafted library with several cleanly reusable utility modules.
Animatelo is a JavaScript library that provides a collection of pre-built animations using the Web Animations API. It ports the popular animate.css library to the JavaScript-based animation model, allowing developers to apply animations like bounce, fade, slide, and more to DOM elements via a simple API (e.g., animatelo.bounce('#element')). The library consists of a core animation engine (src/animatelo.js) that handles element selection, option validation, and animation creation, with individual animation files defining keyframe sequences for specific effects. The architecture is modular, with each animation encapsulated in its own file that extends the main animatelo object, and a build process (via Gulp) concatenates and minifies the source for distribution. The library relies on the Web Animations API (with polyfill support for older browsers) and has no runtime dependencies, making it lightweight and easy to integrate into web projects.
Cocos Creator engine runtime is a cross-platform 2D/3D game engine framework written in TypeScript and C++. It provides a component-entity architecture with scene graph, rendering pipelines (forward/deferred/custom), physics (PhysX, Bullet, Box2D, builtin), animation (marionette state machine, pose graph, Spine, DragonBones), audio, UI, particle systems, and asset management. The engine is designed to be used with the Cocos Creator editor but can run standalone. It abstracts platform-specific APIs (graphics, input, audio, system) behind a common interface, supporting Web, iOS, Android, Windows, macOS, Linux, and various mini-game platforms. Key entry points include the Director, Scene, Node, Component, and the rendering pipeline. External dependencies include graphics APIs (Vulkan, Metal, GLES, WebGPU), physics libraries (PhysX, Bullet, Box2D), and scripting engines (V8, SpiderMonkey, JavaScriptCore).
Cambio is a React component library that simplifies shared-element animations for dialogs/popups. It provides a compound component API (`Cambio.Root`, `Trigger`, `Portal`, `Backdrop`, `Popup`, `Title`, `Description`, `Close`) built on top of Base UI's accessible Dialog primitives and Motion's animation engine. The library offers four built-in motion presets (snappy, smooth, bouncy, reduced) configurable globally, per-component via variants, or overridden individually. It supports dismissible popups driven by drag gestures with configurable threshold and velocity, automatic respect for `prefers-reduced-motion`, and explicit reduce-motion overrides. The architecture uses React Context for state propagation and Motion's `motion.create` to wrap Base UI components. The code is well-typed in TypeScript, organized into clear modules, and demonstrates craftsmanship in its motion configuration resolution chain and drag physics handling. The repository also includes a documentation website built with Next.js and Fumadocs.
This repository implements a web application that serves as a comprehensive cheat sheet for CSS easing functions. Built with TypeScript, Pug, and CSS, it provides interactive visualizations of various easing functions along with their CSS and JavaScript implementations. The application features internationalization support, PWA capabilities with service workers, and a responsive design. Key architectural concerns include modular separation of concerns between helpers, components, and core logic, with build optimization via Parcel-bundler.
WPFDevelopers is a comprehensive WPF custom control library (NuGet package `WPFDevelopers`) that provides ~50+ themed UI controls, styles, effects, window chrome customization, system tray integration, screen capture, charts, loading indicators, and utility helpers. It also includes a demo application showcasing each control. The library targets a wide range of .NET versions (4.0 through 10.0) and integrates Win32 interop for advanced shell features. While containing some vendored code (Microsoft Expression Blend SDK) and occasional duplication, the library demonstrates solid engineering practices with reusable controls, attached behaviors, and a consistent theming infrastructure. It is actively maintained with CI builds for multiple frameworks.
PythonRobotics is a large collection of robotics algorithms implemented in Python, designed primarily for educational purposes and as a companion to a textbook. It covers a wide range of robotics domains including localization (EKF, particle filter, histogram filter), mapping (grid maps, NDT, clustering), SLAM (EKF SLAM, FastSLAM, GraphSLAM), path planning (A*, Dijkstra, RRT variants, PRM, DWA, Frenet, etc.), path tracking (Stanley, LQR, MPC, pure pursuit), arm navigation (inverse kinematics, RRT for arms), aerial navigation (drone trajectory, rocket landing), bipedal walking, inverted pendulum control, and mission planning (state machines, behavior trees). Each algorithm is implemented as a standalone script with a main() function that runs a simulation and visualizes results using matplotlib. The code is not packaged as a library and is not intended for production use; it is a learning resource with clear, readable implementations that reference academic papers. The repository includes extensive documentation in Sphinx RST format, CI/CD pipelines, and a test suite that runs each demo without animation.
OpenMoonRay is an open-source, production-grade path-tracing renderer developed by DreamWorks Animation and hosted under the Academy Software Foundation (ASWF). It is designed for feature film and VFX pipelines, supporting CPU and hybrid GPU (XPU) rendering, physically based materials, and integration with USD-based digital content creation tools via a Hydra render delegate. The system is composed of approximately 20 interconnected submodules covering core rendering, scene representation (RDL2), shaders (Moonshine), distributed computation (Arras), denoising, and more. Key entry points include the `moonray` CLI, `hd_render` for Hydra, `arras_render` for distributed rendering, and a Qt-based GUI (`moonray_gui`). The architecture is modular: the root repository orchestrates builds, provides test data, and houses build scripts and CI configurations, while the actual rendering logic resides in submodules. External dependencies include USD, OpenVDB, Embree, OpenImageDenoise, MaterialX, and Qt5, many of which require local patches for compatibility. The project is actively maintained with regular TSC meetings, CI workflows for Linux and macOS, and a growing open-source community.
This repository provides custom nodes for ComfyUI to enable Deforum-based animation generation. It implements frame-by-frame processing of stable diffusion models with parameter scheduling, allowing users to create animated sequences by evolving prompts, seeds, strength, and other parameters over time. The architecture centers around ComfyUI's node system, with specialized nodes for parameter scheduling, prompt engineering, sampling, latent caching, ControlNet integration, image processing, logic control, video I/O, audio synchronization, and advanced noise generation. A critical execution hijack mechanism modifies ComfyUI's internal processing to handle list operations for frame sequences. The system relies on external libraries like Deforum Studio, ControlNet, RAFT, depth models, and FILM for computer vision techniques.
jupyter-manim is a Jupyter/IPython extension that provides a `%%manim` cell magic for rendering Manim animations and displaying the resulting video or GIF inline in notebooks. It integrates with the manimlib library (specifically the Cairo backend) to execute scene definitions defined in notebook cells, handles exporting notebook variables to the Manim script via pickling, extracts imports from the notebook's global scope, and captures Manim's output to locate and display the generated media file. The architecture centers around the `ManimMagics` class in `jupyter_manim/__init__.py`, which orchestrates the execution flow: executing cell code for early feedback, preparing a temporary script with exported variables and imports, invoking manimlib.main(), and rendering the output using IPython's display system. While the project is functional and serves its niche purpose well, it shows signs of technical drift through inconsistent versioning between setup.py and __init__.py, lack of testing on modern Python versions (only 3.6 and 3.7 in CI), and an aging Travis CI configuration. The codebase contains several reusable utilities such as StringIOWithCallback for stdout capture, is_pickable for safe serialization checks, find_ipython_frame for accessing the user namespace, and video/gif helpers for media display, which demonstrate solid craftsmanship and could be extracted for use in other Jupyter extensions.
This repository is the unified documentation site for the Lottie animation ecosystem, hosted at lottie.airbnb.tech. It is a static website built with Docsify, serving markdown documentation for Lottie's Android, iOS, Web, React Native, Windows, and After Effects integrations. The repo contains no source code for the Lottie libraries themselves; those live in separate repositories (e.g., lottie-android, lottie-ios). The documentation covers installation, usage, API references, supported After Effects features, community showcase, and contribution guidelines. The site is purely informational and does not implement any application logic or data processing.
YapAnimator is a physics-based animation library for iOS, tvOS, and macOS, written in Swift 3.1. It provides a generic `YapAnimator<T>` class that animates any value conforming to the `Animatable` protocol by decomposing it into an array of doubles and applying spring physics integration with a fixed 1/240s timestep. The library includes a convenience layer (`YapAnimatedLayer`) attached to `CALayer` via associated objects, enabling one-liner animations of layer properties like position, bounds, opacity, transform, etc. The core engine runs on a display link (CADisplayLink on iOS/tvOS, CVDisplayLink on macOS) and manages all active animators. The repository is explicitly archived and no longer maintained, with Swift 3.0/3.1 dependencies and no updates since 2017.