GITNUXSOFTWARE ADVICE
Education LearningTop 10 Best 3D Animation Learning Software of 2026
Top 10 ranking of 3D Animation Learning Software for Blender, Maya, and 3ds Max, with technical comparison for learners.
How we ranked these tools
Core product claims cross-referenced against official documentation, changelogs, and independent technical reviews.
Analyzed video reviews and hundreds of written evaluations to capture real-world user experiences with each tool.
AI persona simulations modeled how different user types would experience each tool across common use cases and workflows.
Final rankings reviewed and approved by our editorial team with authority to override AI-generated scores based on domain expertise.
Score: Features 40% · Ease 30% · Value 30%
Gitnux may earn a commission through links on this page — this does not influence rankings. Editorial policy
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Blender
Python-driven operators and scene data access enable end-to-end automation from rig setup to render batching.
Built for fits when teams automate rigs, assets, and renders with Python in a scripted pipeline..
Autodesk Maya
Editor pickMaya Python scripting and API for programmatic rig and animation curve operations.
Built for fits when animation teams need scripted scene assembly and rig automation without replacing the pipeline stack..
Autodesk 3ds Max
Editor pickMaxScript for scene automation using the native object model and modifier stack.
Built for fits when animation teams need scripted throughput for rigs, exports, and shot prep..
Related reading
Comparison Table
The comparison table groups 3D animation learning tools such as Blender, Autodesk Maya, and Autodesk 3ds Max by integration depth, data model, automation and API surface, and admin and governance controls. Each row summarizes how toolchains connect, what scene or asset schema they standardize, and how extensibility affects configuration, provisioning, RBAC, audit log coverage, and sandboxing. The table also highlights automation pathways that impact onboarding throughput and reproducibility for learning workflows.
Blender
Open-sourceBlender is a free open-source 3D creation suite used to learn modeling, rigging, animation, and rendering workflows.
Python-driven operators and scene data access enable end-to-end automation from rig setup to render batching.
Blender provides a workflow engine for animation via armatures, constraints, pose evaluation, and action data that targets specific object channels. The renderer and compositor can be scripted to run deterministic render tasks and post-processing node graphs for batch throughput. The core integration mechanism is Python, which exposes operators, scene data, and dependency graph evaluation for automation and reproducible runs.
A key tradeoff is that automation code often depends on Blender version behavior in areas like operator context and evaluation timing. Blender fits best when a team needs scripted asset generation, rigging automation, or batch renders that connect to existing pipeline tools through Python integrations.
- +Python API drives scene edits, operators, and batch render jobs
- +Add-ons support import and export hooks for pipeline integration
- +Action and armature data model maps animation targets precisely
- +Node-based shaders and compositor graphs serialize for repeatable runs
- –Operator context handling can break scripts across releases
- –Large scenes can slow automated evaluations and render throughput
- –RBAC and audit log features are not built into Blender itself
Best for: Fits when teams automate rigs, assets, and renders with Python in a scripted pipeline.
More related reading
Autodesk Maya
ProfessionalMaya is a professional 3D animation package used to learn character animation, rigging systems, and production-grade effects.
Maya Python scripting and API for programmatic rig and animation curve operations.
Maya supports a node based scene graph with explicit relationships between transforms, geometry, deformers, and animation curves, which helps pipeline tools reason about edits. Pipeline integration is commonly achieved through Autodesk ecosystem components and scripted import and export steps that map to studio schemas for assets and rigs. Automation comes from Python scripting and the Maya API, which can generate or modify rigs, animate constraints, and enforce naming and placement conventions across files. Extensibility also covers custom tools and commands that studios package into reusable toolsets.
A concrete tradeoff is that pipeline governance is not self contained inside Maya, so RBAC, audit logging, and provisioning depend on the asset management and identity layer that stores scenes and publishes outputs. This creates a predictable setup pattern where Maya runs in user workstations or render environments, while access control and audit trails are enforced in the surrounding storage, version control, and production tracking systems. A common usage situation is animation teams that need automated rig cleanup, standardized export, and repeatable scene assembly across many shots.
- +Scene graph data model supports deterministic rig and animation automation
- +Python scripting and Maya API expose nodes, constraints, and animation curves
- +Custom commands and tools can package studio specific workflows
- +Interoperable import and export steps fit asset pipeline schemas
- –RBAC, audit logs, and provisioning are handled by external pipeline systems
- –Automation can be fragile when custom rigs diverge from studio conventions
- –High customization increases maintenance across Maya versions
Best for: Fits when animation teams need scripted scene assembly and rig automation without replacing the pipeline stack.
Autodesk 3ds Max
Professional3ds Max is a 3D modeling and animation tool used to learn scene construction, animation tools, and renderer workflows.
MaxScript for scene automation using the native object model and modifier stack.
3ds Max delivers a controller-centric animation system that maps well to reusable rig and motion setup across many characters. It provides MaxScript automation for scene traversal, batch edits, and repeatable rigging and export tasks. The scene graph and modifier stack create a data model that many pipeline scripts can query and transform. File-based interoperability is strong through common interchange formats such as FBX and Alembic, which helps connect DCC steps before and after animation.
A key tradeoff is that the ecosystem automation surface is split across scripting and plugin mechanisms, so governance and schema-level standardization require custom conventions. File-based workflows can also increase review friction because scene state is embedded in project files rather than stored in a managed database. It fits when animation throughput depends on repeatable exports and rig operations, such as batch generating turntables, caches, or shot-specific renders for a sequencer-driven pipeline.
- +Controller and modifier stack support repeatable rig and motion edits.
- +MaxScript enables batch scene operations and deterministic export routines.
- +Plugin and SDK extension points support custom pipeline tooling.
- +FBX and Alembic interoperability helps connect DCC steps reliably.
- –Automation governance depends on custom naming, layers, and script conventions.
- –Scene state lives in files, which limits centralized schema validation.
Best for: Fits when animation teams need scripted throughput for rigs, exports, and shot prep.
Cinema 4D
Motion graphicsCinema 4D is a 3D motion graphics tool used to learn animation timelines, dynamics, and rendering pipelines.
Python scripting for automating scene graph edits and render setup generation.
Cinema 4D centers on a scene-based data model where objects, materials, and procedural assets stay linked through time and hierarchy. Integration depth comes from standardized interchange formats and extensibility points such as Python scripting, so automation can be wired to repeatable scene tasks.
Its automation and API surface enable provisioning of render setups, asset validation, and pipeline hooks, with extensibility via plugins and custom scripts. Admin governance is mostly indirect, with project organization and asset discipline doing the primary control work rather than centralized RBAC or audit logs.
- +Scene graph data model keeps object, material, and animation connections consistent
- +Python scripting supports automation of scene edits and batch rendering tasks
- +Plugin extensibility enables custom tools for pipelines and repeatable workflows
- +Standard import export formats reduce lock-in across asset sources
- –Centralized RBAC is limited for multi-user governance workflows
- –Audit logs and fine-grained administrative controls are not a first-class surface
- –API coverage for all UI features is uneven across scripting interfaces
- –Pipeline extensibility can raise maintenance overhead for custom plugins
Best for: Fits when teams need scripted scene automation and extensibility inside an established 3D pipeline.
Houdini
Procedural FXHoudini is a node-based procedural 3D animation and effects tool used to learn simulations and complex animation setups.
Houdini Digital Assets with parameterized procedural graphs for pipeline-ready reuse.
Houdini serves as a node-based 3D DCC where procedural animation, simulations, and rendering are authored through a graph-based data model. The integration depth is strongest for pipelines that can connect Houdini Engine via API-driven asset calls, plus automation through command-line tools and Python.
Automation and extensibility are supported through shelf tools, HDAs, Python scripting, and batch workflows that can drive throughput with repeatable graph parameters. Admin and governance controls exist primarily through pipeline-level provisioning and user permissions around project storage, rather than a centralized RBAC console inside the DCC itself.
- +Graph-based procedural data model with HDAs for reusable assets
- +Houdini Engine supports API-driven asset evaluation in host apps
- +Python scripting and batch tools enable repeatable automation runs
- +Configurable build options for nodes that fit pipeline requirements
- –Governance features are limited inside the DCC compared to server tools
- –Large scenes can increase iteration cost due to simulation evaluation
- –Pipeline integration requires engineering effort for production handoffs
- –Debugging complex node graphs can slow automation authoring
Best for: Fits when teams need procedural animation automation with scriptable, pipeline-managed assets.
Unreal Engine
Real-time animationUnreal Engine provides real-time tools used to learn animation systems, virtual production workflows, and interactive rendering.
Control Rig with Sequencer timelines for procedural and keyframed animation in one asset graph.
Unreal Engine fits teams that need tight integration between DCC tools, animation assets, and real-time preview in a shared project workspace. It uses an Unreal asset data model with import pipelines and editor tooling for skeletons, animation sequences, control rigs, and cinematic timelines.
Automation and extensibility are exposed through C++ APIs, Blueprint scripting, command-line tools, and editor automation hooks for batch operations and pipeline throughput. Admin and governance controls are primarily role-based access within the project ecosystem, with audit coverage depending on the external source control and pipeline services used.
- +Real-time animation preview tied directly to the same project assets
- +Control Rig and Sequencer support animation authoring and timeline workflows
- +C++ and Blueprint scripting enable custom automation and editor tooling
- +Command-line execution supports batch renders and pipeline jobs
- –Governance controls rely heavily on external source control and process
- –Asset schema changes can require migration work across large projects
- –Editor automation has a steep learning curve for non-programmers
- –Complex projects can increase iteration time and build throughput needs
Best for: Fits when production teams need controlled animation pipelines with deep engine integration and automation hooks.
Unity
Real-time engineUnity provides real-time 3D workflows used to learn animation rigs, Mecanim systems, and interactive scene building.
Unity Animation Controller state machines for programmable, testable animation flow.
Unity’s differentiation in 3D animation learning comes from editor-first workflows tied to an extensive scripting API and asset ecosystem. The learning experience maps directly to runtime capabilities like animation controllers, timeline sequencing, and physics-verified animation testing.
Integration depth is driven by Unity’s package system, asset import pipeline, and automation hooks for editor scripting. The data model centers on scenes, assets, animation clips, and prefabs, which supports schema-stable extensibility through code and editor tooling.
- +Editor scripting API for automating rig checks and animation import rules
- +Animation Controller and Timeline workflows map to testable runtime behavior
- +Asset import pipeline supports consistent animation clip settings
- +Package and prefab data model enables repeatable learning projects
- –Learning progress depends on editor workflow discipline and asset hygiene
- –Automation requires coding and careful project configuration management
- –Governance controls like RBAC and audit logging are not a first-class surface
- –Large projects can lower iteration throughput without build pipeline tuning
Best for: Fits when teams need animation learning projects with code-driven automation and editor integrations.
Autodesk Learning Hub
CurriculumAutodesk Learning Hub hosts structured learning content that teaches 3D animation tools tied to Autodesk products.
Autodesk product-aligned learning paths inside the same Autodesk user ecosystem.
Autodesk Learning Hub centers learning content delivery inside the Autodesk ecosystem, linking lessons to Autodesk products used for 3D animation workflows. It provides structured modules, instructor-led and on-demand materials, and search across learning assets for role-based skill development.
Integration depth is practical for teams already running Autodesk tooling, since assets connect to the same product families and user journeys. Automation and API surface are limited compared with tools that expose public programmatic access to learning catalogs, completions, and learner events.
- +Tight mapping to Autodesk 3D animation and modeling toolchains
- +Searchable learning paths with consistent module structure
- +Supports on-demand and instructor-led content formats
- –Limited visibility into a public API for completions and learner events
- –Weak extensibility for custom learning content pipelines
- –Governance relies more on Autodesk account controls than detailed learning RBAC
Best for: Fits when teams want Autodesk-aligned training content without building custom LMS integrations.
CG Cookie
Course platformCG Cookie delivers guided 3D learning content focused on practical modeling, texturing, and animation skill-building.
Lesson progression tied to a course library and community practice feedback loop.
CG Cookie delivers structured 3D animation and modeling courses inside a browser-based learning site and video lesson library. The integration depth is limited to what the web experience exposes, with no clear documented API, automation, or external provisioning hooks for course content or learner management.
Its data model centers on course progression and lesson consumption rather than configurable schemas for roles, artifacts, and content pipelines. Admin and governance controls appear to focus on account access and community features instead of RBAC granularity, audit logs, or admin automation.
- +Browser-first course delivery with consistent lesson playback across devices
- +Clear lesson progression and targeted curriculum for 3D animation skills
- +Community feedback channels support iterative practice and critique
- –No documented public API for LMS sync, automation, or provisioning
- –Limited integration surface for authoring tools, CI systems, or pipelines
- –Governance controls lack visible RBAC and audit log capabilities
Best for: Fits when individuals or small groups learn 3D animation without needing system integrations.
Pluralsight
Course libraryPluralsight provides structured courses that teach 3D animation and related technical skills using common industry tools.
Admin audit logging for learning and assignment events tied to account governance.
Pluralsight fits teams that need 3D animation learning content with tight account administration and repeatable rollout across departments. The content delivery is organized around a structured catalog and searchable learning paths, with access controls governed at the user and group level.
Integration depth centers on how learning content and assignments connect to your identity setup, with an API and automation surface designed for provisioning and reporting workflows. Governance relies on role-based access, assignment visibility controls, and audit events to support compliance reviews and operational oversight.
- +RBAC-style access control for user and group assignment scoping
- +Searchable catalog structure supports repeatable learning paths
- +API-oriented automation supports provisioning and integration workflows
- +Audit logging supports compliance and administration review trails
- –Automation coverage is strongest for learning administration, not media pipeline tools
- –Data model focus is learning progress, not production asset metadata
- –Extensibility is constrained versus fully custom LMS-branded schemas
- –Admin controls prioritize access and reporting over deep workflow orchestration
Best for: Fits when departments need governed learning assignments tied to identity and admin automation.
Conclusion
After evaluating 10 education learning, Blender stands out as our overall top pick — it scored highest across our combined criteria of features, ease of use, and value, which is why it sits at #1 in the rankings above.
Use the comparison table and detailed reviews above to validate the fit against your own requirements before committing to a tool.
How to Choose the Right 3D Animation Learning Software
This guide covers software used to learn 3D animation workflows with production-grade authoring tools and learning platforms, including Blender, Autodesk Maya, Autodesk 3ds Max, and Cinema 4D.
It also addresses integration depth, automation and API surface, and admin and governance controls using Houdini, Unreal Engine, Unity, Autodesk Learning Hub, CG Cookie, and Pluralsight as concrete examples.
3D animation learning tools that connect instruction to an automation-capable 3D pipeline
3D animation learning software combines guided practice with authoring environments that store animation data as structured scene or project objects, then enables repeatable runs through scripting, tooling, or learning admin workflows. It helps learners and teams turn lessons into consistent rigs, animation curves, timelines, and shot outputs without manual rework.
Tools like Blender and Autodesk Maya focus on programmatic access to scene nodes, animation targets, and export routines, while Autodesk Learning Hub focuses on structured lesson delivery tied to the Autodesk ecosystem.
Evaluation checklist for integration, data model control, and governance in 3D animation learning
Learning outcomes improve when the tool can persist skill practice as repeatable assets and when those assets can be automated with the same mechanisms used for production. Integration depth matters because lessons are easier to standardize when lesson outputs can slot into an existing asset pipeline.
Automation and API surface decide whether instructors, TDs, and admins can provision learning paths, validate assets, and generate training renders at scale. Admin and governance controls decide who can author content, run automated jobs, and review audit events across users.
Python-driven scene automation that targets animation data and batch renders
Blender automates rig setup and render batching via Python-driven operators and structured access to actions and armatures. Cinema 4D and Maya also use Python scripting to automate scene edits and animation curve operations, which lets learners rehearse workflows through repeatable scripts.
A scene or asset data model that maps animation targets deterministically
Blender stores animation targets as Action and armature data that map precisely to rig workflows, which improves consistency across practice runs. Maya supports scene graph workflows and exposes nodes and animation curves, while Unreal Engine ties animation authoring to Control Rig and Sequencer assets for predictable timelines.
Procedural graph reuse through parameterized assets
Houdini’s Houdini Digital Assets provide parameterized procedural graphs that fit pipeline-ready reuse across shots and lessons. This reduces duplicated rig logic because the same graph parameters can be varied for training exercises.
Extensibility points for pipeline integration via commands, plugins, and SDK hooks
Autodesk 3ds Max uses MaxScript and plugin and SDK extension points to automate scene operations using the native object model and modifier stack. Cinema 4D adds plugins and Python scripting for batch tasks, while Houdini supports reusable HDAs for pipeline handoffs.
Automation and admin governance surfaces for role access and audit trails
Pluralsight provides role-based assignment scoping and audit logging for learning and assignment events, which supports compliance reviews. Maya, Blender, and Cinema 4D rely more on pipeline-level process for RBAC and audit coverage, so governance is typically enforced outside the DCC.
API and orchestration coverage that supports repeatable learning operations
Pluralsight focuses API-oriented automation for learning administration and reporting workflows, which helps provision and track training at scale. Blender’s dependency graph evaluation and Python operator access enables controlled processing, while Unreal Engine offers C++ and Blueprint editor automation hooks for batch operations inside the engine workspace.
Decision framework for choosing a 3D animation learning tool with the right automation and control depth
Start by matching the tool’s automation mechanism to the asset workflow that training outputs must feed. Blender, Maya, and 3ds Max excel when learning needs to convert practice into scripted scene assembly, animation curve edits, and deterministic export routines.
Then validate integration and governance requirements using the tool’s actual API and admin surfaces. Pluralsight fits identity-driven assignment governance with audit log events, while Autodesk Learning Hub focuses on lesson delivery inside the Autodesk user ecosystem.
Map lesson outputs to the same asset structures production uses
If learning exercises must generate rigs and animation data usable in production, Blender’s Action and armature data model or Maya’s scene graph nodes and animation curves are direct matches. If lessons center on timelines and cinematic sequencing, Unreal Engine’s Control Rig and Sequencer asset graph keeps authored motion tied to a shared real-time project structure.
Pick an automation surface that matches the team’s scripting standard
Use Blender or Maya when Python scripting and API access must drive scene edits and animation operations through operators or node access. Use 3ds Max when MaxScript plus modifier stack and controller constructs need deterministic batch scene operations and export routines.
Use procedural assets when training targets simulation and repeatable parameterized setups
Choose Houdini when training relies on procedural animation, simulations, and reusable logic packaged as Houdini Digital Assets. This keeps training variations controlled through graph parameters that can be reused across multiple lessons and shots.
Decide where RBAC, audit logging, and provisioning must live
If learning administration requires RBAC-style access control and audit log trails for assignments and events, Pluralsight provides both. If training relies mainly on DCC scripting without a centralized learning governance console, governance in Maya, Blender, and Cinema 4D typically depends on external pipeline storage access and process rather than built-in RBAC and audit logs.
Validate integration breadth by checking import-export and asset handoff fit
For pipeline interoperability, 3ds Max supports FBX and Alembic export to connect DCC steps reliably. For DCC-to-engine workflows, Unreal Engine uses its project asset data model and editor tooling so animation sequences and timelines are kept inside the engine workspace.
Confirm extensibility depth for custom tooling and repeatable course operations
Choose tools with documented hooks for the kinds of automation needed during training, such as Blender’s Python operators and add-on import-export hooks or Cinema 4D’s Python scripting and plugin extensibility. For teams building governed learning workflows, Pluralsight’s API-oriented automation focuses on learning administration instead of production asset metadata orchestration.
Which teams or learners benefit from specific 3D animation learning approaches and tool surfaces
Different learning outcomes depend on whether the tool primarily provides instruction delivery or authoring-time automation. Tooling that can automate scene changes and renders fits teams that want practice to translate into pipeline artifacts.
Governance needs also split by whether learning admin must tie to identity, group assignment, and audit logs. Learning content platforms like Pluralsight and Autodesk Learning Hub match those needs more directly than DCC-only tools.
Animation teams building scripted rigs, assets, and render outputs
Blender fits this segment because Python-driven operators and access to Action and armature data enable end-to-end automation from rig setup to render batching. Maya and 3ds Max also fit when teams rely on Python API node and animation curve automation or MaxScript batch operations for throughput.
Studios standardizing procedural animation training with reusable parameterized graphs
Houdini fits teams that want procedural animation automation via Houdini Digital Assets with parameterized procedural graphs. This supports lesson reuse because learners can change parameters while keeping the same graph-based asset structure.
Teams needing timeline and animation learning tied to an interactive real-time project workspace
Unreal Engine fits teams that require Control Rig and Sequencer timelines for procedural and keyframed animation in one asset graph. Unity fits teams that want editor-first workflows tied to runtime animation controllers and timeline sequencing for testable behavior.
Departments rolling out governed learning assignments across identities and groups
Pluralsight fits departments that require role-based assignment scoping and audit logging for learning and assignment events. This segment typically benefits from Pluralsight’s API-oriented automation for provisioning and reporting.
Learners focusing on structured Autodesk-aligned instruction without custom LMS integrations
Autodesk Learning Hub fits when instruction needs to map to Autodesk product workflows inside the Autodesk user ecosystem. It delivers searchable learning paths and role-based skill development without emphasizing public automation hooks for learner events.
Failure modes when choosing 3D animation learning tools with mismatched automation and governance
Many selection errors come from assuming that a DCC authoring tool includes centralized learning governance features. Other errors come from picking a tool for lessons but then discovering that the automation surface does not cover the kind of provisioning, batch operations, or schema validation the training requires.
Common issues also appear when teams underestimate the operational cost of large-scene processing or complex node graph debugging during automated lesson runs.
Choosing a DCC without a governance plan for RBAC and audit logs
Blender, Maya, and Cinema 4D do not provide built-in RBAC and audit log controls inside the DCC, so learning governance must be enforced through external pipeline process. Pluralsight offers audit logging tied to learning and assignment events, which removes the need to retrofit governance from outside.
Assuming all tools expose a comparable automation and provisioning API for learning events
CG Cookie and Autodesk Learning Hub focus on lesson delivery and do not provide a clearly documented public API for LMS sync, completions, or learner events. Pluralsight provides API-oriented automation for learning administration and reporting workflows instead.
Optimizing for manual authoring when the training depends on repeatable scripted operations
Unreal Engine’s editor automation and scripting hooks are stronger once the team commits to C++ or Blueprint automation patterns. Blender and Maya remain better matches when training requires Python-driven scene edits and deterministic batch work across rigs and animation curves.
Ignoring throughput costs from evaluation-heavy workflows during automated practice
Blender can slow automated evaluation and render throughput on large scenes, and Houdini can increase iteration cost because simulation evaluation occurs in procedural graphs. Tight training scripts should use controlled scene sizes in Blender and parameterized, well-scoped graph setups in Houdini to keep lesson batch runs practical.
Building pipelines around conventions that automation cannot enforce consistently
3ds Max automation can become fragile when naming, layers, and script conventions drift across teams because scene state lives in files. Maya automation can also break when custom rigs diverge from studio conventions, so shared rig schemas and validation steps must sit outside the learning workflow.
How We Selected and Ranked These Tools
We evaluated each tool using editorial scoring across features coverage, ease of use, and value for 3D animation learning workflows, then we produced an overall rating as a weighted average where features carry the largest share, and ease of use and value each share the next largest portion. The scope covered integration and automation mechanisms described in the tools’ capabilities, plus how governance and audit coverage appear through built-in surfaces or external pipeline process.
Blender set itself apart by pairing a high feature score with Python-driven operators and scene data access that enable end-to-end automation from rig setup to render batching, which directly improves learning throughput for scripted practice. That automation and the Action and armature data model lifted the features and ease-of-use components for learners who want their lesson outputs to become pipeline-ready assets.
Frequently Asked Questions About 3D Animation Learning Software
Which platform fits scripted rigging and animation assembly across Blender, Maya, and 3ds Max?
How do Houdini and Cinema 4D differ for procedural animation and pipeline automation?
What tool pairs best with real-time preview for learning animation workflows tied to a game engine?
Which learning platform supports extensibility for custom import, export, and scene operations?
Can these tools integrate with an external pipeline via APIs and automation hooks?
Which option supports learning content administration with stronger audit and role controls?
How does identity and SSO planning differ across Pluralsight, Autodesk Learning Hub, and CG Cookie?
What data migration challenges show up when moving course tracking or project assets between tools?
Why do admin controls feel centralized in Pluralsight but less centralized inside the DCC tools?
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
Keep exploring
Comparing two specific tools?
Software Alternatives
See head-to-head software comparisons with feature breakdowns, pricing, and our recommendation for each use case.
Explore software alternatives→In this category
Education Learning alternatives
See side-by-side comparisons of education learning tools and pick the right one for your stack.
Compare education learning tools→