GITNUXSOFTWARE ADVICE
Video Games And ConsolesTop 10 Best Computer Game Creation Software of 2026
Top 10 Computer Game Creation Software picks ranked by power, ease, and performance, with Unity, Unreal Engine, and Godot compared.
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.
Unity
Unity Editor with C# scripting plus Timeline and Animator integration
Built for studios needing a flexible engine for multi-platform PC and mobile games.
Unreal Engine
Editor pickNanite virtualized geometry
Built for studios building high-end visuals and gameplay systems with strong technical support.
Godot Engine
Editor pickScene system with instancing and packed scenes for fast composition of game content
Built for indie teams building 2D and 3D games with open editor workflows.
Related reading
Comparison Table
This comparison table benchmarks Unity, Unreal Engine, Godot Engine, GameMaker, CryEngine, and other game creation tools by integration depth, data model, automation and API surface, and admin and governance controls. Each row maps how assets, scenes, and project configuration are represented in a schema, how extensibility plugs into the build pipeline, and what RBAC, audit log, and provisioning controls exist for team operations.
Unity
game engineUnity provides a real-time game engine with an editor, physics, rendering, asset workflows, and deployment tools for multiple platforms.
Unity Editor with C# scripting plus Timeline and Animator integration
Unity stands out for its mature game engine workflow that spans 2D, 3D, and real-time interactive content. It delivers core authoring tools, a component-based scene system, scripting with C# and visual graph tools, and a robust asset import pipeline.
Strong platform reach supports PC, console, and mobile targets plus XR. Built-in profiling and rendering features help teams iterate on performance while building production-ready gameplay systems.
- +C# scripting and visual graphs cover gameplay logic and iteration speed.
- +Component-based scene workflow streamlines building and refactoring game objects.
- +Cross-platform build pipeline supports PC, mobile, console, and XR targets.
- +Integrated profiler and debugging tools speed up performance investigation.
- –Large projects need careful architecture to avoid tangled scripts.
- –Rendering and asset pipeline tuning can become complex for beginners.
Indie studios shipping cross-platform titles
Build PC and mobile gameplay systems
Faster multi-platform launches
Console and PC game teams
Optimize frame time with profiling tools
Improved runtime performance
Show 2 more scenarios
XR development groups
Author real-time interactions for headsets
More reliable XR prototypes
Unity enables spatial interaction prototyping with platform-specific XR pipelines for immersive application behavior.
Technical artists and content teams
Create scenes using component workflows
Less scene integration rework
Component-based scenes and visual tools support collaborative content setup while maintaining consistent gameplay integration.
Best for: Studios needing a flexible engine for multi-platform PC and mobile games
More related reading
Unreal Engine
game engineUnreal Engine offers a full-featured game engine with visual scripting, advanced rendering, animation tooling, and platform deployment support.
Nanite virtualized geometry
Unreal Engine supports full production workflows through its editor and runtime, including level design, gameplay scripting, and cinematic authoring with Sequencer. The engine includes Niagara for authoring particle and simulation-based VFX systems, plus Control Rig for procedural and reusable character animation. Tooling includes landscape and foliage workflows for open worlds, and it supports scalable content pipelines for shipping builds.
A tradeoff is that reaching high-fidelity visuals often requires careful performance profiling across rendering features, materials, and lighting settings. It fits teams building interactive 3D experiences that need real-time feedback for iteration, such as large environments, camera-driven sequences, and physics-aware gameplay systems.
- +Blueprints and C++ combine rapid iteration with deep engine-level control
- +Nanite and Lumen enable high detail and dynamic lighting with fewer tradeoffs
- +Sequencer and Control Rig streamline cinematic animation and timeline authoring
- –Editor and build workflows require strong hardware and performance tuning
- –Learning curve is steep for rendering, asset pipelines, and engine architecture
- –Packaging, platform certification, and optimization can be time-consuming
Indie teams building 3D worlds
Prototype with real-time world iteration
Faster scene iteration cycles
AAA cinematic animation teams
Author gameplay and cinematics together
Consistent character performance
Show 2 more scenarios
Real-time VFX artists
Build simulation-driven visual effects
More controllable VFX output
Artists use Niagara graphs for particle behaviors, gameplay-linked events, and reusable VFX modules.
Studios optimizing open-world performance
Profile and tune large landscapes
Stable performance in production
Studios use landscape workflows and render settings to balance detail density with frame-rate targets.
Best for: Studios building high-end visuals and gameplay systems with strong technical support
Godot Engine
open-source engineGodot is an open-source game engine that includes a scene-based editor, scripting for gameplay, and export tools for multiple targets.
Scene system with instancing and packed scenes for fast composition of game content
Godot Engine stands out with an open-source, MIT-licensed core and a fully integrated editor for building 2D and 3D games. It supports a scene-based workflow, a GDScript language, and multiple rendering pipelines through its Vulkan and OpenGL backends.
Core capabilities include real-time tools, physics integrations, animation systems, and export pipelines that target desktop and mobile. The engine also offers extensibility via custom C# scripting and native modules for deeper engine-level features.
- +Scene-based workflow keeps UI, levels, and entities modular and reusable.
- +GDScript plus C# support covers fast iteration and stronger tooling options.
- +Built-in editor includes live editing, debugger, and profiling tools for iteration.
- +Strong 2D toolset with sprite, tilemap, and animation support.
- +Physically based 3D rendering features with flexible material workflows.
- –C# workflows depend on platform setup and editor tooling maturity.
- –Advanced rendering customization can require deeper engine knowledge.
- –Large-scale team pipelines often need extra conventions around assets and scenes.
Indie studios and solo developers
Ship 2D and 3D indie titles
Faster prototype to release
Game jams and rapid prototypes
Prototype mechanics with scene workflow
Shorter time to playable
Show 2 more scenarios
Technical educators and student teams
Teach GDScript and game systems
Hands-on engine-based learning
Instructors assign projects using the built-in editor, scripting, and physics integration.
Modders and custom tool builders
Extend editor features and runtime behavior
Tailored workflow for projects
Developers add custom scripts and modules to integrate bespoke pipelines and tooling.
Best for: Indie teams building 2D and 3D games with open editor workflows
GameMaker
2D-focusedGameMaker delivers a workflow for building 2D games using a visual editor and scripting for game logic and game export.
Event sheets combined with GML for object-based gameplay logic
GameMaker focuses on 2D game creation with an event-driven logic model, which supports rapid iteration without forcing full engine programming. The editor pairs sprite and timeline workflows with GML scripting for gameplay systems, UI, and persistence.
Export targets cover common desktop builds and desktop-focused deployment workflows for finished games. This tool is distinct for how it combines visual object logic and code into one project structure.
- +Event-driven object logic speeds up common gameplay wiring
- +GML scripting supports custom mechanics beyond visual logic
- +2D animation workflows integrate sprites and timelines cleanly
- +Strong debugging tools help track runtime errors quickly
- +Export pipeline supports practical desktop game deployment
- –Primarily 2D workflows limit usefulness for 3D-heavy projects
- –Project scaling can feel rigid when projects grow large
- –Advanced tooling for complex asset pipelines is limited
- –Performance tuning requires deeper engine knowledge
Best for: Solo or small teams building 2D desktop games with mixed visual scripting and GML
CryEngine
AAA engineCryEngine supplies a real-time rendering-focused engine with level editing tools, scripting support, and deployment tooling.
CryEngine renderer with advanced real-time global illumination and physically based materials
CryEngine stands out with highly detailed real-time rendering, including advanced lighting and environmental effects aimed at next-gen visuals. Core capabilities cover scene editing, asset pipelines, and gameplay system support using engine tools designed for building interactive worlds. The toolset includes strong terrain and environment authoring workflows, plus mature support for animation, physics, and rendering optimization.
- +High-end rendering features for realistic lighting and materials
- +Production-focused editor tooling for world building and iteration
- +Strong terrain and environment creation workflows for open spaces
- –Complex toolchain increases onboarding time for new teams
- –Gameplay scripting and customization can require deeper engine knowledge
- –Editor workflows can feel heavy without strong asset and pipeline practices
Best for: Teams building graphically intensive PC games with strong technical leadership
Construct
no-codeConstruct enables game creation through event-based logic, behavior systems, and publishing exports for web and other targets.
Event Sheet visual scripting with conditions and actions tied to game objects
Construct centers on an event-driven visual workflow that builds game logic without coding, using a node-based layout editor. It combines this system with real-time rendering support for 2D games and exports built projects for desktop and mobile.
Built-in physics and sprite-based object behaviors let developers prototype mechanics quickly and then refine them with custom scripts where needed. The editor supports importing assets and organizing objects, events, and scenes into a structure that scales for typical 2D gameplay projects.
- +Event-based logic builds gameplay without writing large code blocks
- +2D sprite workflow and layout tools speed up iteration and level creation
- +Physics and collision behaviors are ready for common platformer mechanics
- +Export targets cover desktop and mobile use cases for 2D games
- +Supports custom scripting when visual events hit edge-case limitations
- –Visual event graphs can become hard to maintain at large scale
- –Tooling focuses on 2D workflows and limits deeper 3D game needs
- –Complex systems often require careful event organization to avoid bugs
- –Performance tuning for heavy logic can be less direct than code-first engines
Best for: Solo devs and small teams building 2D games with visual logic
RPG Maker
RPG builderRPG Maker supports building role-playing games with map editors, battle systems, and character scripting and exports.
Event Commands with parallel processes for creating reactive gameplay systems
RPG Maker stands out with a large RPG-focused toolkit built for creating tile-based role-playing games. Core capabilities include map editing, event-driven logic, character and battle systems, and project packaging into distributable builds. The workflow emphasizes visual configuration over full code control, which speeds up story and level iteration.
- +Event system enables complex gameplay without writing full game logic
- +Tile map editor supports quick level layout and iteration
- +RPG battle and party systems provide ready-to-configure mechanics
- –Extending beyond RPG conventions often requires scripting
- –Engine constraints can limit deep custom UI and non-RPG systems
- –Large projects may become harder to maintain with event-heavy logic
Best for: Solo creators or small teams building classic RPGs fast with events
Blender
3D contentBlender is a 3D creation suite used for modeling, UV unwrapping, rigging, animation, and exporting assets into game engines.
Non-destructive modifier stack plus animation-ready rigging workflow for exportable character assets
Blender stands out for combining full 3D modeling, rigging, animation, simulation, rendering, and game-targeted tooling in a single application. The built-in Blender Game Engine pipeline is not actively maintained, so real-time game development typically relies on exporting assets to other engines.
Strong animation tools, node-based material shading, and efficient asset workflows support creating game-ready characters, environments, and VFX content. For interactive behavior, Blender primarily serves as a content authoring suite rather than a complete, engine-level game runtime.
- +End-to-end content creation with modeling, sculpting, rigging, and animation tools
- +Node-based materials and Cycles rendering produce game-ready shading and lighting
- +Powerful modifiers and non-destructive workflows speed environment and prop iteration
- –No actively maintained in-editor game runtime for shipping interactive gameplay
- –Steep learning curve for hotkeys, navigation, and advanced node workflows
- –Asset export and engine integration adds extra steps for gameplay implementation
Best for: Studios producing game assets and animation in one integrated DCC tool
Aseprite
pixel artAseprite provides pixel-art sprite creation with animation timelines, layers, and export workflows for game-ready assets.
Frame-by-frame timeline editor with onion skinning for sprite animation
Aseprite stands out with a pixel-editor workflow built around frame-by-frame animation tools and sprite-sheet friendly export. It supports onion skinning, palette management, layer-based editing, and timeline playback to iterate quickly on game assets.
Export targets include sprite sheets and animated GIF, and the editor can also import sprite data for refinement passes. The tool fits game creation teams that prioritize pixel-art clarity, tight control over frames, and asset consistency.
- +Timeline-driven animation editing with onion skinning
- +Layer support enables modular sprite assembly
- +Pixel-precise tools like palette controls and snapping
- +Sprite-sheet and animated exports for game asset pipelines
- +Keyboard-first workflow speeds repetitive sprite edits
- –Limited 3D support compared with modern game content suites
- –No built-in rigging or skeletal animation authoring
- –Advanced effects require careful manual setup
- –Large projects can feel slower with many layers and frames
Best for: Pixel-art game asset production for small teams and solo creators
Spine
2D animationSpine lets teams create 2D skeletal animations and export runtime data for integration into games.
Mesh deformation skinning driven by bones for smooth, reusable character motion
Spine is a 2D character animation tool centered on creating skeletal rigs with skinning and timeline-based animation. It exports game-ready animations for engines and supports blending, mesh deformation, and bone-driven parts.
The workflow is highly specialized for character animation in games, not general-purpose level editing or scripting. Integration is strongest when the target pipeline already expects skeletal animation data and atlas-style rendering.
- +Skeletal rigging with mesh deformation for efficient character animation
- +Timeline keyframing supports controlled motion and reusable animation tracks
- +Game-oriented export includes bones, animations, and attachments for runtime playback
- –Specialized workflow demands rigging discipline beyond typical sprite animation
- –Complex rigs take time to set up and debug across animations
- –Less suited for non-character animation tasks like environment layout
Best for: Studios producing 2D skeletal character animation for games
Conclusion
After evaluating 10 video games and consoles, Unity 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 Computer Game Creation Software
This buyer's guide covers Computer Game Creation Software tools used to build game levels, gameplay logic, animation, and asset pipelines across Unity, Unreal Engine, Godot Engine, GameMaker, CryEngine, Construct, RPG Maker, Blender, Aseprite, and Spine. It focuses on integration depth across authoring and export, the underlying data model, and automation plus API surface so production workflows stay controlled.
The guide also compares how Unity, Unreal Engine, and Godot Engine differ for power, ease of use, and runtime performance characteristics. It highlights concrete mechanisms like component scene workflows in Unity, Nanite virtualized geometry in Unreal Engine, and instancing plus packed scenes in Godot Engine.
Evaluation criteria for integration, data model control, automation, and governance
Game creation tooling changes behavior and throughput based on the data model behind scenes, objects, and assets. A controlled data model supports repeatable provisioning of scenes and assets and reduces breakage when projects scale.
Integration depth matters because teams rarely ship from one tool alone. Unity and Unreal Engine connect editing, profiling, and gameplay scripting into a single engine workflow, while Blender, Aseprite, and Spine target asset and animation export that must integrate into an engine runtime.
Scene graph and object composition model
Unity uses a component-based scene workflow that streamlines building and refactoring game objects without rewriting entire structures. Godot Engine uses a scene system with instancing and packed scenes to keep UI, levels, and entities modular and reusable for composition at scale.
Gameplay logic wiring model and maintainability
GameMaker combines event sheets with GML so gameplay logic and object structure stay in one project model for quick wiring of common behavior. Construct and RPG Maker rely heavily on event-driven visual logic, and their event graphs can become hard to maintain when project complexity increases.
Rendering and content pipeline depth for iteration
Unreal Engine pairs Nanite virtualized geometry with Lumen for dynamic lighting while keeping fidelity high, which can demand performance tuning and editor build workflow discipline. CryEngine centers on advanced real-time global illumination and physically based materials, which benefits teams with strong technical leadership for rendering iteration.
Profiling, debugging, and performance investigation mechanics
Unity includes an integrated profiler and debugging tools that speed up performance investigation while iterating on production-ready gameplay systems. Godot Engine includes a built-in editor with live editing, debugger, and profiling tools that support rapid iteration across 2D and 3D.
Animation authoring surface and runtime data export readiness
Unity integrates Timeline and Animator tooling to coordinate animation and gameplay sequencing inside the engine editor. Spine exports game-oriented skeletal animation data like bones, animations, and attachments, which fits engines and pipelines that expect atlas-style rendering and bone-driven parts.
Extensibility and editor pipeline customization options
Godot Engine supports extensibility via custom C# scripting and native modules for deeper engine-level features when built-in editor workflows need adjustment. Unity and Unreal Engine cover broad scripting options too, with C# in Unity and Blueprints plus C++ in Unreal Engine, but large projects still need architecture conventions to avoid tangled scripts.
A decision framework for selecting the right game creation toolchain
The selection process should start from the production workflow shape, not from the target game genre alone. The core question is whether the tool's scene and logic data model supports the way content will be authored, reviewed, and changed over time.
The next question is integration depth across authoring and export. Blender, Aseprite, and Spine often serve as specialized content pipelines that must integrate into Unity, Unreal Engine, or Godot Engine for gameplay runtime and level assembly.
Match the scene data model to project scale and reuse needs
For modular composition at scale, choose Godot Engine because its scene system supports instancing and packed scenes for fast composition of game content. For teams that benefit from component refactoring across objects, choose Unity because its component-based scene workflow streamlines building and refactoring game objects.
Pick a gameplay logic model that stays maintainable in real production
For event-driven gameplay wiring with a tight object-centric structure, choose GameMaker because event sheets pair with GML in one object logic model. For logic that becomes complex over time, avoid assuming visual event graphs stay readable by default and plan structure discipline in Construct and RPG Maker.
Select the rendering pipeline that fits the fidelity target and tuning capacity
Choose Unreal Engine when Nanite virtualized geometry and Sequencer-driven cinematic workflows are central goals, because high-fidelity work still requires careful performance profiling across rendering features. Choose CryEngine when advanced real-time global illumination and physically based materials drive the visual plan and the team can handle onboarding and pipeline complexity.
Verify profiling and debugging coverage for the iteration loop
Choose Unity when integrated profiler and debugging tools need to support performance investigation quickly during gameplay iteration. Choose Godot Engine when built-in live editing, debugger, and profiling tools must keep iteration fast while authoring and exporting.
Decide whether animation work is engine-native or export-only
Choose Unity when Timeline and Animator integration must coordinate animation and gameplay sequencing inside the same editor workspace. Choose Spine when the pipeline is driven by skeletal rigging and the runtime expects exported bones, animations, and attachments for 2D character motion.
Plan a content pipeline around specialized authoring tools if needed
Choose Blender when the primary requirement is non-destructive modifier workflows and animation-ready rigging for exporting characters and environments to a game engine runtime. Choose Aseprite when the main output is pixel-perfect sprite animation with onion skinning and timeline-driven frame editing that feeds into Unity, Godot Engine, or GameMaker asset imports.
Tooling fit by team goals, asset types, and workflow maturity
Different game creation tools emphasize different production workflows, so fit depends on whether the team builds engine runtime systems or specializes in content and animation export. Integration depth requirements usually split teams into engine builders and asset pipeline builders.
Governance needs also vary because event graphs, component refactors, and large-scale rendering pipelines each create different change-management risks for multi-person projects.
Studios targeting multi-platform PC and mobile with a flexible engine workflow
Unity fits studios that need a cross-platform build pipeline plus C# scripting and an editor workflow with Timeline and Animator integration. Unity also supports integrated profiling and debugging, which helps keep performance investigation inside the same tool.
Studios building high-end visuals with strong cinematic and animation tooling
Unreal Engine fits teams building interactive 3D experiences that require high-fidelity rendering like Nanite virtualized geometry and dynamic lighting with Lumen. Unreal Engine also supports Sequencer and Control Rig for cinematic timelines and procedural character animation, which raises production control for camera-driven sequences.
Indie teams that want open workflows and modular scene composition
Godot Engine fits indie teams that want an open-source editor with a scene system built for instancing and packed scenes. Godot Engine also supports both GDScript and C# scripting, which supports fast iteration when scripting language choices matter.
Solo devs and small teams focused on 2D gameplay with visual logic
Construct fits small teams that want event-based logic with node-style layouts and built-in physics and sprite-based object behaviors for 2D platformer style mechanics. GameMaker fits solo and small teams that want event sheets combined with GML for object-based gameplay logic in a single project structure.
Teams that need specialized 2D character animation or pixel-precise sprite assets
Spine fits studios producing 2D skeletal character animation that must export bone-driven runtime data for smooth reusable motion. Aseprite fits small teams making pixel-art assets because it provides timeline-driven frame editing with onion skinning and sprite-sheet friendly exports.
Common procurement and implementation pitfalls that create rework
Most failures in game creation tool selection come from mismatch between a tool's data model and the way content will be edited and scaled by multiple people. Logic systems can also become hard to maintain if governance conventions are not defined early.
Rendering-heavy pipelines and event-driven authoring both increase the cost of poor asset organization, and those costs show up quickly during performance tuning and gameplay iteration.
Choosing a visual event graph tool without planning structure rules
Construct can become difficult to maintain when visual event graphs grow large, so teams should define naming, object grouping, and event organization conventions early. RPG Maker can also get harder to maintain with event-heavy logic, so extend only within the RPG event model and add scripting when complex non-RPG systems appear.
Underestimating architecture discipline for large engine projects
Unity large projects need careful architecture to avoid tangled scripts, so teams should set component boundaries and refactor rules for scene and behavior separation early. Unreal Engine editor and build workflows require strong hardware and performance tuning, so teams should plan optimization passes across materials and lighting from the start.
Expecting a content DCC tool to handle runtime gameplay
Blender does not provide an actively maintained in-editor game runtime for shipping interactive gameplay, so teams must export assets into an engine runtime like Unity, Unreal Engine, or Godot Engine. Aseprite and Spine also focus on asset and animation outputs, so they must integrate into an engine workflow for levels and gameplay scripting.
Treating specialized animation export as a general-purpose animation system
Spine specializes in skeletal rigging and export runtime data, so it is less suited for environment layout and non-character animation tasks. Aseprite specializes in pixel-art sprite animation, so it needs engine integration for effects, physics, and rendering behavior.
How We Selected and Ranked These Tools
We evaluated Unity, Unreal Engine, Godot Engine, GameMaker, CryEngine, Construct, RPG Maker, Blender, Aseprite, and Spine using a criteria-based scoring approach focused on features, ease of use, and value. Each tool received an overall rating computed as a weighted average in which features carried the most weight at forty percent, and ease of use and value each accounted for thirty percent. This scope used only the documented review signals for standout capabilities, concrete pros and cons, and the reported features, ease of use, and value scores.
Unity separated itself from lower-ranked tools by combining C# scripting with an editor workflow that integrates Timeline and Animator and by pairing that with an integrated profiler and debugging tools for performance investigation. That combination lifted both features and ease-of-use for real iteration loops, which increased its overall rating relative to tools that either specialize in content export like Blender, Aseprite, and Spine or lean heavily on visual event graphs like Construct and RPG Maker.
Frequently Asked Questions About Computer Game Creation Software
How do Unity, Unreal Engine, and Godot differ in script-to-game architecture for interactive gameplay?
Which toolset best fits teams that need high-fidelity rendering while keeping performance iteration manageable?
What integration and API options exist for automating content builds and pipeline steps?
How do admin controls, SSO, and audit logging typically map to game authoring environments?
What data migration issues appear when moving existing assets into Unity, Unreal Engine, or Godot projects?
When teams avoid general-purpose engines, which tools cover 2D logic authoring without full engine programming?
Which workflow is best for creating and reusing skeletal character animations across engines?
How do rendering backends and export targets differ for 2D and 3D projects in Godot, Construct, and GameMaker?
What common technical bottlenecks cause stalled progress when building a production-sized game project?
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
Video Games And Consoles alternatives
See side-by-side comparisons of video games and consoles tools and pick the right one for your stack.
Compare video games and consoles tools→FOR SOFTWARE VENDORS
Not on this list? Let’s fix that.
Our best-of pages are how many teams discover and compare tools in this space. If you think your product belongs in this lineup, we’d like to hear from you—we’ll walk you through fit and what an editorial entry looks like.
Apply for a ListingWHAT THIS INCLUDES
Where buyers compare
Readers come to these pages to shortlist software—your product shows up in that moment, not in a random sidebar.
Editorial write-up
We describe your product in our own words and check the facts before anything goes live.
On-page brand presence
You appear in the roundup the same way as other tools we cover: name, positioning, and a clear next step for readers who want to learn more.
Kept up to date
We refresh lists on a regular rhythm so the category page stays useful as products and pricing change.