Skip to content

Getting Started

Welcome to RevFramework — a modular, developer-first toolkit for Unity.
This guide walks you through the essential steps to start using the framework confidently.

If you would rather understand the shape of the thing before wiring anything up, Why It Works This Way covers the handful of choices that are visible in your project long before their reasoning is — where the framework installs, why the scene services are large files, and where authority deliberately stops.

Prefer to watch first?

The onboarding series covers the same ground in four short videos: what the framework is and is not, the Teachable Panels, how to read these docs, and a live demonstration of removing and restoring systems from a real project. The first one is embedded on the home page.

Before You Begin

Unity Requirements

  • Unity 6.0 or later
  • Supports Built-in, URP, and HDRP
  • Runtime systems are fully render-pipeline agnostic

Project Recommendation

Create a clean Unity project when exploring RevFramework

Many templates override:

  • Input settings
  • Layers
  • Physics
  • Render Pipeline Assets
  • Scene defaults

A clean project avoids hidden conflicts while learning the systems.

Importing RevFramework

Import either:

  • A single SKU, or
  • The Complete Bundle

No null refs. No broken chains. No cleanup required.

After import:

  • Runtime systems compile immediately
  • Editor tools activate automatically
  • Systems you didn’t install simply remain inactive

It installs under Assets/, not Packages/

RevFramework lands in Assets/RevFramework rather than installing as a UPM package, because you are meant to read it, cut parts out of it, and keep the samples and guides somewhere you will actually open them. Where It Installs covers the reasoning.

The part that affects you today: keep your own scripts, prefabs and scenes outside Assets/RevFramework, so a future update stays a re-import rather than a merge.

Build Size & Optional Content

RevFramework separates runtime code from editor and learning tools.

For player builds: - Only the Runtime/ folder is required
- Samples, Teaching, Documentation, and DebugTools are optional

These folders are safe to remove once you’re done learning or testing.

Pre-Build Clean archives them — it does not delete them

Tools ▸ RevGaming ▸ RevFramework ▸ Validate ▸ Pre-Build Clean moves them out of Assets into _RevFramework_Trash_PreBuild, beside Assets, under a mirror of their project paths. To get them back, move that tree back over Assets/ — you do not need to re-import the package.

Two things worth knowing: the clean deliberately ends the current build, because the folders back define symbols and Unity cannot recompile against changed symbols mid-build, so build again afterwards. And Restore From Trash… does not read this folder — that window covers the separate orphan-cleanup trash.

If you deleted them by hand rather than cleaning, re-import the package or SKU.

Render Pipeline Note

Demo scenes use URP/Lit materials by default.

Pink demo meshes on Built-in or HDRP

If you're using Built-in or HDRP, you may see pink demo meshes. This affects visuals only — systems still work identically.

To convert visuals:

  • Swap to your pipeline’s Standard/Lit shaders, or
  • Use Unity’s Render Pipeline Converter

The sample scenes also expect two packages, and it is not only cosmetic

This page used to mention pink materials and nothing else. The scenes carry real component references to two Unity packages, and without them Unity cannot load those components:

Package Scenes affected Without it
Input System (com.unity.inputsystem) 34 the EventSystem object carries a missing script where InputSystemUIInputModule should be, so uGUI demo interaction has no input module and does not respond
Universal RP (com.unity.render-pipelines.universal) 9 affected cameras carry a missing script

A missing script is not a pink material — the object loads with a broken component and Unity logs it. Install both packages before opening the samples, or expect those specific scenes to be inert rather than merely mis-shaded.

This affects the sample scenes only. Neither package is a hard dependency of the framework: no Runtime/ assembly references either one. UnityInputService probes for the Input System reflectively and falls back to the legacy input path when it is absent, so the framework runs either way — it is the scenes' serialized component references that cannot survive the package being missing.

First Steps Inside Unity

1️⃣ Open a Quickstart Scene

Every system includes a minimal scene under:
Samples/Systems/<System>/Scenes/
The entry scene is the one numbered 00_; its name varies by system.

Covers the basics in 30–60 seconds.

2️⃣ Press Play to see the Teachable Panel

Interactive overlays showing logic, flow, debugging, and behaviour.

There is nothing to open — panels are components already placed in the sample scenes. Press Play and the overlay draws itself. Select the panel's object in the Hierarchy to retune it in the Inspector.

3️⃣ Explore full sample scenes

Complete system coverage, multi-character setups, adapters, and real runtime behaviour.

Reopening the welcome window

The welcome window opens by itself the first time you import RevFramework, and it carries the shortcuts to the documentation, the free test-suite download, and the Discord.

It is a once-ever popup, not once per project — so on your second project it will not appear, and that is deliberate rather than a fault. Open it whenever you want from:

Tools ▸ RevGaming ▸ RevFramework ▸ Help ▸ Show … Welcome

There is one entry per package — Complete Bundle, Inventory, Pickups & Crafting, Health & Status Effects, Currency & Economy — and each is greyed out unless the systems it covers are installed, so the one you can click is the one you own.

You do not need to understand the entire framework to use it.

Start with any system available in your project:

  • Inventory — visual, UI-friendly, easy to reason about
  • Health — self-contained, clear cause → effect
  • Pickups or Status Effects — small, focused systems demonstrating the result-first pattern

If you have Currency or Economy, these systems are intentionally stricter.
Explore them once you're comfortable with RevFramework’s result-first and authority patterns.

For any system:

  1. Open its Teachable Panel (Editor-only)
  2. Run the matching Sample Scene
  3. Read the system’s documentation guide and overview
  4. Wire it into your own code, prefabs, and UI

Once one system makes sense, the Cookbook shows what two can do together

These pages teach systems one at a time. The Cookbook shows what the public seams let you compose from several — a shop that charges in health, loot odds that read the player's condition, a craft that cannot half-happen.

Each recipe is one class you copy into an existing project, and each page states the systems it needs and the traps found while writing it. It lives on the site rather than in the package: recipes are yours to adapt and own, not part of the supported runtime surface.

Start simple

Use what you need. Go deeper only when you want to.