VeloScroll | Infinite Recycling ScrollView for uGUI

Build large, dynamic uGUI lists, grids, tables, feeds and menus without instantiating one GameObject for every data item.

A conventional ScrollRect implementation that creates every row at once grows its hierarchy with the dataset. At 100,000 rows, that means 100,000 cell GameObjects before the user starts scrolling.

VeloScroll virtualizes the view instead. It keeps a bounded set of cells around the viewport and recycles those cells as the visible range moves. The hierarchy therefore stays roughly the same size whether your data contains a few hundred entries or 100,000.

Use it for inventories, shops, leaderboards, chat histories, quest logs, save browsers, galleries, settings menus, pickers, carousels, live feeds and virtualized data tables.

VeloScroll recycles whatever cell prefab and visual style you supply. It provides the scrolling, pooling, layout, interaction, data and authoring layer rather than forcing a bundled UI theme onto your project.

Try it before you buy it.

The interactive WebGL showcase is built with the shipped runtime and contains sixteen hands-on modules. Scroll a 100,000-item list, switch between layouts, snap and page, drag rows to reorder, import your own CSV, and jump directly to index 50,000.

Watch the status bar while you test it: it displays the current live-cell count and the total number of cells ever instantiated.

Bounded cell recycling you can measure

VeloScroll drives a standard uGUI ScrollRect by composition rather than subclassing it, so it fits the Canvas, viewport, mask and input workflow you already use.

A Recycler calculates the visible index range. A CellPool supplies cells for that range and takes them back when they leave it. Multi-prefab layouts maintain a separate pool for each cell type.

The recycling behavior is exposed through two public properties:

• LiveCellCount — the number of cells currently active
• TotalCellsCreated — the total number of cell instances created since initialization

The package does not ask you to accept the optimization claim on trust. In the 100,000-item showcase, you can scroll or jump deep into the dataset while watching both values.

The package's documented verification also records:

• 12 live cells for 100-, 10,000- and 50,000-item test cases
• 9 live cells for a 10,000-item shipped-player case
• No pool growth over a 1,000-tick scroll test
• Zero managed allocation in the recycler's steady-state bookkeeping

Lists, grids, masonry, sections and tables

Available virtualized layouts include:

• Vertical lists
• Horizontal lists
• Variable-height or variable-width single-track lists
• Fixed-column or fixed-row grids
• Staggered masonry grids with variable item heights
• Sectioned lists with separate header and row binding
• Sticky section headers that pin and hand off as the next section arrives
• Virtualized tables with configured columns and an optional frozen header
• Multi-prefab lists that select a cell type per index and pool every type separately

The same view can be reconfigured through the Inspector or at runtime.

Snapping, paging and scrolling interaction

Interaction features include:

• Start-, Center- and End-aligned snapping
• OnSnap events reporting the resolved item index
• Viewport-based paging
• Instant or animated ScrollToIndex
• Seamless looping
• Auto-scroll marquees
• Pull-to-refresh
• Load-more events
• Drag-to-reorder
• Nested-scroll routing

VeloScrollNestedRouter passes vertical drag input to a parent list when an inner scroll view reaches its edge, allowing nested layouts without permanently trapping the gesture inside the child.

Dynamic data

Bind data through IVeloScrollDataSource or the supplied runtime methods:

• SetData
• SetDataSource
• Reload
• InsertItems
• RemoveItems
• RefreshVisible

Live-count delegates let the view follow a collection whose size changes at runtime.

For an Inspector-driven workflow, VeloScrollDataSource ScriptableObject assets provide reusable no-code rows.

VeloScroll does not own your model. It requests the current count and binds data only when a cell becomes visible.

CSV and JSON import

Import tabular data with:

• VeloScrollImport.FromCsv
• VeloScrollImport.FromJson
• VeloScrollImport.Auto
• VeloScrollImport.FromFile

Each method produces VeloScrollTabularData, which can be projected into a list or table.

The CSV reader supports:

• UTF BOM removal
• Automatic comma, semicolon, tab and pipe delimiter detection
• RFC-4180-style quoted fields
• Embedded delimiters
• Embedded newlines
• Doubled-quote escaping
• Ragged-row padding

The JSON reader supports:

• Top-level arrays
• Arrays stored inside wrapper properties
• Single objects
• Unioning record keys into one schema
• Flattening nested objects into dotted columns such as address.city

Every imported column begins enabled. Call SetIncluded(column, false) to hide internal or unwanted fields without modifying the original data.

ApplyAsTable and ApplyAsList send the selected projection directly into a VeloScroll view.

Scroll-driven cell effects

VeloScrollAnimator provides four effects driven by each visible cell's position inside the viewport:

• FocusScale
• Parallax
• Fade
• Depth

Effect strength and falloff can be configured with a curve.

Reusable VeloScrollAnimationPreset and VeloScrollTheme assets make it possible to share presentation settings across multiple views.

Inspector and no-code authoring

Add VeloScrollView to an existing UI object, or create a ready-to-use view through:

• GameObject > UI > VeloScroll > Recycling List
• GameObject > UI > VeloScroll > Recycling Grid

The custom Inspector exposes:

• Layout
• Data
• Cell prefab
• Animation
• Theme
• Snapping
• Preview
• Live statistics

The package also includes:

• A Welcome window
• A documentation menu entry
• Create-menu entries for data-source assets
• Create-menu entries for animation presets
• Create-menu entries for themes
• VeloScrollProjectValidator configuration checks

The Inspector-first path is suitable for designers and rapid prototyping, while the public API supports fully code-driven data and behavior.

Evidence you can run yourself

94 automated tests ship inside the package and run locally through Unity's Test Runner.

Imported into a clean Unity 6000.0.62f1 URP project, the recorded result is:

• 60/60 EditMode tests passing
• 34/34 PlayMode tests passing
• Zero compile errors

The tests cover recycling, bounded cell counts, layouts, scrolling behavior, runtime data changes, import and integration paths.

Full C# source included

The package contains 54 C# source files across 10 assembly definitions covering runtime, Editor, demo, samples and tests.

There are:

• No managed DLLs
• No precompiled assemblies
• No native plugins
• No P/Invoke calls

You can inspect, extend and debug the full implementation.

No third-party runtime dependencies

The core runtime requires only Unity's standard uGUI package.

There is no core TextMeshPro requirement, no Newtonsoft JSON dependency, no native plugin, and no hosted service.

The CSV and JSON readers, recycling system, cell pools and layout calculations are implemented inside the package.

VeloScroll makes no runtime network calls of its own.

Known limitations

Stated up front, because discovering them after purchase is worse.

• UI Toolkit is not supported. VeloScroll is a uGUI asset. It is not the correct package for a project whose runtime interface is built entirely with UI Toolkit.
• No controller or gamepad focus navigation is included. Scrolling is designed for pointer, touch and mouse-wheel input. Controller-selection movement between recycled cells is not implemented.
• Variable-size cells apply to single-track lists. Fixed grids use a uniform size along the scrolling axis. Use the masonry layout when you need a staggered grid with variable item heights.
• The listed verification was performed on Unity 6000.0.62f1. The package targets Unity 2021.3 LTS and newer and contains a Unity 2021.3 font-fallback path, but the published test results come from 6000.0.62f1.
• The demo is a functional showcase, not a UI kit. Its cells are deliberately simple. VeloScroll recycles and binds the prefab you provide instead of shipping a visual style that must later be removed.

Requirements

Unity 2021.3 LTS or newer, including Unity 6.

The core runtime requires uGUI (com.unity.ugui).

The scaffolded and included demo scenes use Unity's Input System for their pointer-event setup. The core recycler itself uses uGUI drag handlers and works with either supported input backend.

Built-in Render Pipeline, URP and HDRP are supported because the runtime is plain uGUI and adds no custom shaders or materials.

The package includes:

• Sixteen sample and demo scenes
• One sixteen-module interactive showcase
• A single searchable HTML manual

The documentation covers installation, quick start, recycling behavior, lists, grids, variable sizes, animations, snapping, paging, masonry, sticky sections, looping, pull-to-refresh, multi-prefab cells, themes, tables, reordering, nested scrolling, CSV/JSON import, dynamic data, Editor tooling, compatibility, the scripting API and troubleshooting.