The Unity uGUI Advanced Reference explains the system, not the buttons

This is a reference book about Unity's uGUI, delivered as a PDF

The repository holds a document rather than a library. The title is Unity uGUI Advanced Reference, and the download instructions point at a single PDF file called Unity_uGUI_Advanced_Reference.pdf, with a note that the file is large enough that the preview on the hosting site may not render it properly. The top level of the tree confirms the shape of the project: a README.md, the PDF itself, a LICENSE file, and two content directories, English/ and Markdown/. The primary language is recorded as unknown because the repository holds no source code, and the licence field records the Unlicense. So what you are evaluating is a written reference on the Unity uGUI user interface system, and the question that matters is whether it teaches the mechanism or merely lists the knobs.

The stated audience is people who want the underlying principles

The target reader section is unusually direct about who will be disappointed. The book is written for readers who want to understand the fundamental principles of Unity's uGUI deeply, and it says that if you expect tips that produce an immediate effect or a catalogue of useful UI assets, you may be disappointed. That framing tells you the book's method: it explains why the system behaves as it does rather than listing what to click. The motivation is given as a set of recurring situations. A handy UI asset turns out not to support your platform. A Unity version upgrade breaks a handy UI asset. Or a handy UI asset stops working when you have done nothing at all. The claim is that understanding the contents lets you respond calmly to those situations. It also states the book's value for performance work, since the well known uGUI optimisation techniques are said to make sense once you have read through the book. The performance techniques the book lists are the standard ones any Unity developer has seen. Splitting the Canvas. Reducing unnecessary RaycastTargets. Avoiding the use of Camera.main. Trying not to use Auto Layout's Layout Group. Avoiding animating the UI with Animation or Timeline. What the book adds is the reasoning, since the claim is that after reading it you will understand why those techniques are effective rather than treating them as folklore. That is a real difference in kind, because the folklore version of this advice cannot tell you when the rule does not apply. The RaycastTarget point in particular depends on how the event system decides what was clicked, and the Camera.main point depends on how the camera lookup works, and neither is self explanatory from the API surface. The book does not stop at performance either, since it also covers the rendering order in Unity, shaders, texture formats and import settings, RenderTexture and screen resolution.

Every component entry was verified by calling it, not copied

The methodology statement is what makes this different from the official API documentation. The book documents the properties of the uGUI components and their public methods, and it states that these explanations are not copies of the official reference, but the result of the author reading the source code, actually invoking the calls and verifying the behaviour. Where a notable garbage collection allocation occurs, a note is added. That is a specific and demanding standard, and it explains the shape of the reference: you get the behaviour of each call, including the ones that allocate, rather than a signature list. The premise underneath is that reading a reference and the source code of middleware end to end is a genuinely useful way to understand it, and that reading this book in full gives an understanding of Unity as a whole and not only of uGUI. The practical value for a working developer is that the notes about allocation are the ones you cannot get anywhere else, because they are the difference between a call that is cheap and a call that spikes the GC.

Eleven chapters covering the whole UI stack

The table of contents is the clearest evidence of coverage, and it runs to eleven chapters. Chapter one is Canvas and the components around it, including CanvasScaler, GraphicRaycaster and CanvasGroup. Chapter two covers the UI elements and the Canvas rebuild, with the UIBehaviour class, RectTransform, CanvasRenderer, the Graphic components and the rebuild process itself, plus a section on achieving variable resolution on smart devices. Chapter three is rendering, with draw order, rendering performance, shaders, texture formats and import settings, RenderTexture and screen resolution. Chapter four is Graphic and VertexHelper, and chapter five is images and effects, covering RawImage versus Image, Shadow, Outline, PositionAsUV1, Mask and RectMask2D. Chapter six is text and fonts, with the Text component, TextGenerator, font assets, the TrueTypeFontImporter and TextMesh Pro. Chapter seven is Selectable and its family of Button, Toggle, ToggleGroup, Slider, Dropdown, InputField and Scrollbar. Chapter eight is the Scroll View, chapter nine is Auto Layout in detail, chapter ten is the EventSystem and chapter eleven is profiling, with the Unity Profiler, the Frame Debugger and how to read the CPU Usage area.

Auto Layout gets a chapter of its own, and a warning

Chapter nine is longer than any other, and it is the clearest statement of the book's priorities. It covers the overview of Auto Layout, the size determination rules of Layout Element, manual sizing through the Layout Element component, Layout Controller, Layout Group, the driven properties of RectTransform, how to build your own Auto Layout component, the layout calculation, what triggers a layout rebuild, and then the four interfaces involved: ILayoutElement, ILayoutController, ILayoutSelfController and ILayoutIgnorer. It then walks the concrete components, LayoutElement, LayoutGroup, HorizontalOrVerticalLayoutGroup, HorizontalLayoutGroup, VerticalLayoutGroup, GridLayoutGroup, ContentSizeFitter and AspectRatioFitter, and ends with a chapter section titled using Anchor rather than Auto Layout. That last section is the point of the whole book in miniature, because the performance advice about avoiding Layout Group is not a prohibition but an explanation of when Anchor is the better tool.

The event system and the profiling chapter close the loop

Chapter ten treats the input side with the same thoroughness, covering the EventSystem component, the messaging system, InputModule, StandaloneInputModule, BaseInput, the Event Trigger component, the Raycaster family with GraphicRaycaster, PhysicsRaycaster and Physics2DRaycaster, and how to extend StandaloneInputModule. This is the chapter that connects back to the RaycastTarget advice, because the raycaster decides what receives a pointer event and the EventSystem decides how that travels. Chapter eleven then closes with profiling: the profiling tools for uGUI, the Unity Profiler, the Frame Debugger, and how to read the CPU Usage area along with the patterns of causes that show up there. Ending the book with measurement rather than with the component list is what makes it usable as a working tool rather than a reference to consult once and forget.

Unity 2020.2 is the baseline, with later features folded in

The book is written for Unity 2020.2 as its baseline, and it also intends to cover uGUI features added before that version as they come up. The examples it picks out are the ones a reader may not know about, such as the soft mask feature of the Mask component introduced in Unity 2020.1, which is the blurred edge, along with premultiplied transparency in the UI shaders and padding of the raycast area. That is a small but telling detail, because the soft mask and the raycast padding are exactly the features whose effect on performance and on hit testing is invisible unless someone points them out. The licence arrangement is also worth reading. The sample code in the book, whether derived from Unity uGUI or original, is distributed under the Unity uGUI licence, with the documentation URL given, and the readme notes that products usually already carry the Unity uGUI licence attribution so nothing special has to be done.

Where this book is the wrong choice

The first wrong case is a developer who wants quick wins, because the readme says plainly that expecting tips with an immediate effect will disappoint, and a book that takes eleven chapters to reach the EventSystem is not a lookup table. The second is a team on a recent Unity version whose uGUI behaviour has moved, since the baseline is 2020.2 and the content covers features added up to that point, so anything introduced afterwards is outside its scope. The third is a reader who does not read Japanese and wants the original, because the readme and the repository's primary content are in Japanese, and while the tree has an English/ and a Markdown/ directory, what they contain is not described here. The fourth is a team that wants a maintained reference with versioned API, since there are no GitHub releases, the repository is a document rather than a package, and the PDF is a single file that either works on your Unity version or does not. The fifth is an artist or designer rather than a programmer, since the whole book is written about component properties, public methods and source code behaviour.

Editorial conclusion

Unity developers who want to understand why the interface system behaves as it does, especially anyone chasing a performance problem in a canvas or trying to work out why a UI asset broke after an upgrade, are the people this book is for, and the notes on where each call allocates are the part you cannot get from the official reference. It is the wrong choice for a developer looking for a quick fix, since the readme says outright that readers expecting tips with an immediate effect will be disappointed, and it is the wrong choice if you are on a Unity version much later than 2020.2, since that is the baseline the book is written against. Check three things before you start: that the Unity version your project runs on is close enough to 2020.2 for the described behaviour to hold, that you can read the content in a language you are comfortable with, since the primary content is Japanese and the English and Markdown directories are not described in the readme, and whether you have the patience for eleven chapters, because the Auto Layout chapter alone runs to four interfaces and eight components before it reaches the argument for using anchors instead. The sample code is distributed under the Unity uGUI licence, the repository publishes no GitHub releases, and the last push was on 2026-09-28.

Frequently asked questions

Official sources

1. heppoko/Unity_uGUI_Advance_Reference on GitHub
2. Issues
3. License: Unlicense
4. README