Graphy for Unity: an FPS counter and stats monitor you drop into a scene

What Graphy is for, and who ends up using it

Graphy is a Unity package that puts a stats overlay on top of a running game. The README lists three things it graphs and prints as text: FPS, memory and audio. Alongside those it exposes advanced device information and a set of debugging tools. The stated purpose is to let you visualize and catch a hiccup or stutter when it happens, rather than reconstruct it later from a log.

The audience is narrow but real. If you are a Unity developer who needs to know whether a scene holds its frame rate on a target device, Graphy answers that question without leaving play mode. It is not a general telemetry system and it is not aimed at server-side or non-Unity work. The topics on the repository describe it as a stats monitor for Unity, and the package.json sets the minimum editor version at 2022.3, so projects on older editors are out of scope for version 4.0.0. The README points to a v1.6.0 release for Unity 5.4 and newer, which is the only backward path it offers.

The debugger is the part that separates it from a plain frame counter. The README describes setting one or more conditions that, when met, produce consequences you choose: taking a screenshot, pausing the editor, printing a message to the console, or calling a method from your own code. That last option is what makes the tool scriptable rather than just readable. You decide what a frame-time spike means for your project.

How the overlay, the graphs and the debugger fit together

The repository layout is the clearest description of the architecture. At the top level there are separate folders for Runtime, Editor, GUI, Shaders, Materials, Textures, Font and Prefab. That split tells you the package ships compiled runtime code, an editor-side custom inspector, and the visual assets the overlay draws with. The README notes that the C# and shader code are documented, and that the package supports both the Built-in and Universal Render Pipelines, which is why the shader folder exists rather than a single hardcoded material.

The data flow is straightforward. Runtime code samples frame timing, memory and audio, the GUI layer renders those samples as graphs and text using the bundled prefab and materials, and the editor layer exposes a custom inspector so you configure the module without editing code. A hotkey system toggles the overlay, and a background mode is listed among the additional features, which matters because an overlay that only updates while the window has focus would miss the moments you care about.

Configuration lives in the scene, not in a config file. That is a deliberate trade-off. It makes the overlay trivial to set up and easy to see, and it means the settings travel with the scene rather than with a build profile. The cost is that anything you want to compare across scenes has to be set up more than once, and a prefab that is edited in one place can drift from another. The README does not describe a central settings asset, so plan on treating each placement as its own configuration.

The debugger conditions run against the same sampled values the graphs display. What you see on screen and what fires the action come from one source, which removes the usual gap between a visual observation and a scripted response. The README does not document the full list of condition types, so the bundled PDF is where you would confirm them.

Installing Graphy and getting a first reading

There are four install paths in the README, and the openupm CLI is the shortest. It adds the package by name from the openupm registry:

openupm add com.tayx.graphy

If you prefer to stay inside the editor, the README gives a scoped registry route. Under Edit > Project Settings > Package Manager > Scoped Registries, add an entry named package.openupm.com with the URL https://package.openupm.com and the scopes com.openupm and com.tayx.graphy. After that, Window > Package Manager with Packages set to My Registry lists Graphy as something you can download. The README also allows a git URL, added to the dependencies block of manifest.json:

{
  "dependencies": {
    "com.tayx.graphy": "https://github.com/Tayx94/graphy.git"
  }
}

The fourth route is the Unity Asset Store listing linked from the README. Whichever you pick, the package name is com.tayx.graphy and the version in the repository's package.json is 4.0.0.

For a first real use, you need the overlay in the scene. The repository ships a Prefab folder, and the README describes Graphy as something you add to your Unity project rather than something you start from the command line. Drop the Graphy prefab into the scene, enter play mode, and the graphs and text should appear over the game view. From there the custom inspector is where you switch layouts, adjust the look, and set the debugger conditions. The README does not spell out the exact prefab file name, so open the Prefab folder and pick the Graphy prefab it contains. If you want to drive the overlay from code instead of the inspector, the README advertises an easy to use API accessible from code, but it does not print the method names; those are in the bundled PDF.

Where Graphy stops being the right tool

The biggest limitation is visible in the roadmap, not in the feature list. Storing FPS for a predetermined time to allow benchmarks is listed as a planned feature with no ETA. So is dumping all Graphy data as a string to a file, to a server, or by mail. If your goal is a repeatable benchmark that produces a number you can compare between commits, Graphy in its current form does not do that. It shows you the present, and the present disappears when you stop play mode. You would be reading values off the screen and writing them down.

There is a second constraint that bites in shipping builds. The roadmap lists a preprocessor key #GRAPHY to avoid adding the asset in builds, and it is still planned. Until that exists, the overlay is part of the build unless you strip it yourself. That is fine for an internal test build and wrong for a release. The README does not document a supported way to exclude the package per build target, so plan on removing it from the scene or excluding it at the project level.

Platform coverage is described as working on multiple platforms, without a list. The README does not enumerate which ones, so if you are targeting a console or a less common platform, that is a question for the Discord or the forum thread before you build a workflow around it. The same silence applies to the audio module: it is listed as a graph, but the README does not say what it measures, so do not assume it covers anything beyond what you can see in the overlay.

Graphy against the Unity Profiler

The obvious alternative is the Unity Profiler, and the difference is one of shape rather than of quality. The Profiler records a session and lets you scrub through it afterward, with per-frame breakdowns by system. Graphy draws live graphs over the running game and, through the debugger, reacts at the moment a condition is met. One is a recorder you analyze later; the other is an alarm you watch now.

That distinction decides which one you want. If you are hunting a stutter that happens once every few minutes and you need to know which subsystem caused it, the Profiler is built for that and Graphy is not, because the README lists no capture-and-review workflow. If you are standing in a scene on a target device and want to see the frame rate fall the instant you enable a feature, Graphy is the shorter path, and the debugger's ability to pause the editor or take a screenshot at that instant is something the Profiler does not do in the same way.

They are not mutually exclusive, and the README does not position Graphy as a replacement. Treat it as the always-on readout and the Profiler as the deep dive. The one place they overlap awkwardly is benchmarking, where the Profiler records and Graphy does not yet.

Maintenance, licensing and what an upgrade costs

The repository is not archived. The last push was on 2026-08-29, which is the same day as the v4.0.0 release tagged Graphy 4.0.0 - Unity 2022.3. Before that, the previous release was v3.0.5 on 2023-11-15, with v3.0.4 a week earlier. That gap is worth noting: the project moved from 3.0.5 to 4.0.0 after roughly two and a half years, and the version jump to a major number alongside the Unity 2022.3 requirement suggests the upgrade is not a drop-in for everyone.

The upgrade cost is concentrated in the editor version. If you are on an editor older than 2022.3, version 4.0.0 is not for you, and the README's only suggestion is the old v1.6.0 release for Unity 5.4 and newer. That is a large jump backward in features, so an older project is effectively choosing between staying on a 3.x release and moving the editor forward.

Graphy is released under the MIT license, and the package.json repeats that as the license field. MIT is permissive, so you can use it in a commercial project. The README says attribution is not required but that the author would like to hear about it. That is a request, not a term. I am not a lawyer and this is not legal advice; if your organisation has a policy on third-party assets, the LICENSE file at the repository root is the document to hand to whoever reviews it.

Editorial conclusion

Adopt Graphy if you are on Unity 2022.3 or newer and want an in-scene FPS, memory and audio readout with conditional debugger actions, installed through openupm, the Package Manager scoped registry, a git URL in manifest.json or the Asset Store. Do not adopt it if you need a headless benchmark harness or a profiler that records across a whole session; the roadmap lists storing FPS for a set time and dumping data to a file, a server or mail as planned features with no ETA, so neither exists yet. Before you commit, open the PDF documentation bundled at the repository root and confirm the debugger condition types and the API surface match what you need, then check whether the preprocessor key #GRAPHY listed on the roadmap has shipped, because until it does every build carries the overlay unless you remove it yourself.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. Tayx94/graphy on GitHub