# LWGUI for Unity: Shader Inspector Controls and Workflows

> LWGUI is a C# Unity package for building custom ShaderLab and Amplify Shader Editor inspectors through drawers, decorators, presets, ramps, and Timeline integration. It suits technical artists who need more control than Unity's default material inspector provides.

**JasonMa0012/LWGUI** — A Lightweight, Flexible, Powerful Shader GUI System for Unity.

- Repository: https://github.com/JasonMa0012/LWGUI
- Stars: 1,431 · Forks: 113
- Language: C#
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/jasonma0012-lwgui

## What LWGUI Changes in a Unity Material Inspector

LWGUI addresses a specific limitation in Unity shader authoring: the material inspector is usually defined by shader properties and a custom editor class, which can make a large shader difficult to present clearly to artists. LWGUI provides a system for describing inspector elements through Drawers and Decorators. The README describes concise Material Property Drawer syntax, a modular extension architecture, MetaData lifecycle caching, Ramp and Preset tools, a toolbar, and Timeline integration. These features target the gap between shader logic and the controls used to manipulate materials.

The intended users are Unity shader authors and technical artists who build inspectors for material workflows. The package is especially relevant when a shader exposes many numeric controls, keywords, gradients, textures, vectors, or conditional settings. It also supports visual editing of LWGUI Attributes in Amplify Shader Editor when ASE is installed. That integration is optional and requires a separate configuration step, so LWGUI is not limited to the native ShaderLab inspector.

The project description calls the system lightweight and flexible, but its practical value comes from the authoring model. Rather than building every inspector element directly in editor code, a project can attach attributes to shader properties and extend those attributes with custom Drawers and Decorators. The repository layout includes separate Editor, Runtime, UnityEditorExtension, and Test directories, indicating that the package contains editor-facing functionality alongside supporting runtime and test code.

## LWGUI Drawers, Decorators, and Material Property Flow

The central mechanism is the Material Property Drawer. The README's Getting Started section directs shader authors to configure drawers for properties in a code editor. Its basic and extra drawer sections list controls for enums, numeric values, ramps, textures, vectors, colors, buttons, and built-in Unity property types. A drawer determines how a shader property appears in the inspector.

Decorators add presentation and behavior around those controls. The documented Extra Decorators include Title, Tooltip and Helpbox, Hidden, HelpURL, ReadOnly, ActiveIf, ShowIf, PassSwitch, Advanced, and AdvancedHeaderProperty. These components can change layout or make a property visible, hidden, read-only, or active according to another condition. This separation gives shader authors a structure for composing an inspector rather than placing every interface concern in one custom editor class.

The package also models more than individual controls. Preset creation and editing are included under the Preset drawer. Ramp drawers can edit gradients from ShaderLab or C#, and RampAtlas can include multiple ramps in one Texture. RampAtlasIndexer is documented separately. These features support a workflow in which a material property refers to a ramp asset or atlas index while the drawer supplies an editor for selecting and editing that value. The README does not explain the complete serialization details, so a project should inspect the repository before choosing an asset structure.

For Timeline, MaterialKeywordToggleTrack records changes to a Toggle's Keywords. According to the README, this allows material keywords to switch at runtime. That is a distinct operation from changing a numeric material property because it connects shader keyword state to Timeline animation.

## Installing LWGUI 1.41.0 and Completing a First Use

The documented installation path uses Unity's Package Manager. LWGUI version 1.41.0 declares Unity 2021.3 in package.json. The README separates compatibility ranges: LWGUI versions below 1.17 support Unity 2017.4 and later, while LWGUI 1.17 and later require Unity 2021.3 or later. It recommends Unity 2022.2 or newer while noting that lower versions may contain bugs.

Open the Unity project, select `Window > Package Manager > Add > Add package from git URL`, and enter the repository URL below.

```text
https://github.com/JasonMa0012/LWGUI.git
```

The README also permits downloading the Zip manually and selecting `Package Manager > Add package from disk`. For Unity 2017, it specifically says to extract the Zip directly into the `Assets` directory. This route concerns older Unity versions and should not be treated as the normal installation path for the current package.

A first useful workflow is to open a shader or its material inspector and inspect the LWGUI attributes attached to its material properties. The available controls are documented across Main and Sub, Enum, Numeric, Ramp, Texture, Vector, and Other. After adding an attribute such as a Ramp, Preset, or Enum drawer through the project's shader setup, open the corresponding material in Unity and check whether the inspector presents the documented control. The README does not include a complete copy-and-paste shader example, so it does not establish an exact attribute sequence to reproduce.

For Amplify Shader Editor, install ASE version `v1.9.9.10` or later, open `Project Settings > LWGUI > ASE Integration`, and enable the setting. The documentation states that this replaces ASE's default Custom Editor with `LWGUI.LWGUI`. Create or open an Amplify Shader, create or select a Parameter node, and LWGUI Drawer and Decorator editing becomes available according to the README.

## Ramps, Presets, ASE Integration, and Timeline Boundaries

LWGUI's feature set is strongest when the shader contains reusable visual assets or coordinated material settings. The Ramp system includes a gradient editor for ShaderLab and C#, plus RampAtlas support for placing multiple ramps in one Texture. The SampleAmplifyShader is mentioned as a starting point, which can reduce the initial work for an Amplify-based project. However, the README does not document the exact inspector settings, file format, or migration procedure for converting an existing shader into a RampAtlas workflow.

Presets are documented as a separate creation and editing feature. Their presence is useful for material authors who need repeatable groups of values, but the README does not explain how preset conflicts are resolved, whether changes are tracked by Unity, or how presets behave when a shader property is renamed. Those are project-specific checks rather than assumptions to make during adoption.

The optional ASE integration also has a concrete boundary. It requires ASE `v1.9.9.10 +`, and enabling it changes the Custom Editor selection to `LWGUI.LWGUI`. Projects that need ASE's default custom editor behavior must account for that replacement. LWGUI does not remove the need to understand ASE nodes, shader parameters, and the generated shader structure.

Timeline support is narrower than general Timeline automation. The documented MaterialKeywordToggleTrack handles changes to a Toggle's Keywords. It does not claim that arbitrary LWGUI controls, gradients, textures, or preset values can be animated through the same track. Artists who need broad Timeline control over every material value may need another integration.

## Compatibility, Maintenance, and Upgrade Cost for LWGUI

The repository is not archived, and the last push was on 2026-07-14. Recent releases include 1.41.0 on 2026-07-14, 1.40.1 on 2026-06-09, and 1.40.0 on 2026-05-26. These facts show recent repository activity, but the README does not promise a release schedule, long-term support policy, or compatibility with every future Unity release. The version-specific Unity requirement is the firmer adoption boundary.

LWGUI adds an editor extension and a shader authoring convention to the project. That introduces maintenance work beyond simply accepting built-in Unity controls. Shader attributes must remain aligned with property names and supported drawer types. Custom Drawers or Decorators can add further code that must track Unity editor changes. The repository includes Test and UnityEditorExtension directories, but the README does not list a test command or explain how to execute the tests.

The package is identified by the MIT license. That permits broad use and modification under the license terms, but a team still needs to preserve required license text and notices and review its own distribution obligations. The README also mentions sponsorship, but sponsorship is not a technical compatibility or maintenance guarantee.

For upgrades, the first check should be the Unity version used by the project, followed by the LWGUI version and any ASE version already present. A project should also verify that its custom Drawers, Decorators, presets, and shader attributes still resolve after upgrading. The README does not provide a rollback procedure, migration script, or detailed version compatibility table beyond the Unity ranges noted there.

## Why Unity's Built-in Shader GUI May Be Better

Unity's built-in Shader GUI remains the direct alternative for shaders whose default inspector is sufficient. It requires no additional package installation and keeps the shader's material controls close to Unity's native behavior. That makes it a reasonable choice for small shaders, prototypes, and projects that do not need conditional decorators, ramp atlases, presets, ASE editing, or Timeline keyword tracks.

The difference is architectural. Unity's built-in drawers expose standard property types and keyword controls, while LWGUI composes a custom inspector from attribute-based Drawers and Decorators. LWGUI adds authoring conventions and extension points, so it can represent a more deliberate material workflow, but the team owns the integration cost and must validate custom editor behavior. The two approaches can coexist when different shaders have different needs.

LWGUI is the wrong choice when the main requirement is a single simple numeric range or toggle and adding a package would complicate delivery. It is also a poor fit if the team cannot maintain editor code or accept version-specific Unity requirements. The package becomes more defensible when many materials share a complex inspector and the same controls need to be presented consistently.

## LWGUI Adoption Checks for Unity Shader Teams

LWGUI fits Unity teams that repeatedly build material inspectors for complex shaders and need a reusable attribute-based system rather than isolated custom editor scripts. Its documented drawers cover common material controls, while Decorators handle layout, conditional display, help text, and advanced grouping. The RampAtlas, Preset, ASE, and Timeline features target recurring production problems, but each introduces a dependency or a project-specific integration choice.

Teams should not adopt it merely because the package description uses promotional language. First confirm that the project runs Unity 2021.3 or later for LWGUI 1.41.0, or that it is intentionally using the older compatibility route. If ASE is part of the shader workflow, confirm ASE `v1.9.9.10 +` is acceptable and review the effect of `Project Settings > LWGUI > ASE Integration`. Then inspect existing shaders and custom editors for conflicts.

The final decision depends on whether the team can support custom Drawers, Decorators, presets, and shader attributes during Unity upgrades. LWGUI is a substantive editor extension, not just a visual theme. Its adoption boundary is clearest when a project needs coordinated material controls across many shaders and can accept the package's Unity version and editor integration requirements.

## Conclusion

Adopt LWGUI when your Unity project needs custom material inspectors, attribute-driven controls, or Timeline keyword switching. Do not choose it as a replacement for Unity's built-in inspector if you need zero project configuration or cannot accept an editor extension. Verify Unity version compatibility, ASE requirements, and material lifecycle behavior before integrating version 1.41.0.

## FAQ

### How do I install LWGUI in Unity?

For LWGUI 1.41.0, open `Window > Package Manager > Add > Add package from git URL` and enter `https://github.com/JasonMa0012/LWGUI.git`. The README also describes downloading the Zip and using `Package Manager > Add package from disk`.

### What Unity version does LWGUI 1.41.0 require?

LWGUI 1.41.0 declares Unity 2021.3. The README recommends Unity 2022.2 or later and warns that lower compatible versions may contain bugs.

### Does LWGUI work with Amplify Shader Editor?

Yes, but the README requires ASE `v1.9.9.10 +` and enabling `Project Settings > LWGUI > ASE Integration`. It states that ASE's default Custom Editor will then be replaced with `LWGUI.LWGUI`.

## Sources

- [Issues](https://github.com/JasonMa0012/LWGUI/issues)
- [JasonMa0012/LWGUI on GitHub](https://github.com/JasonMa0012/LWGUI)
- [License: MIT](https://github.com/JasonMa0012/LWGUI/blob/1.x/LICENSE)
- [README](https://github.com/JasonMa0012/LWGUI/blob/1.x/README.md)
- [Releases](https://github.com/JasonMa0012/LWGUI/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jasonma0012-lwgui