This is an introduction to the fundamental concepts of Uniform, Sparseal’s general purpose, art focused data editor.

As artists ourselves, we are aware of the main limitations that current 3D asset creation pipelines have. We designed Uniform based on a different architecture and workflow so we can tackle those issues head on. This also allows us to take full advantage of the new capabilities of modern hardware and software.

If you already have experience with 3D graphics, you will see that some concepts in Uniform don’t map directly to software you may be used to. Uniform was not built with the scope of being just sculpting or poly modeling software. It can do those tasks, but the overall design covers many more use cases. You will see that Uniform’s approach is actually pretty simple and learn how it can help you optimize your current workflows.

What is Uniform?

Let’s start with something simpler, creating 2D graphics with computers. We usually have two ways of representing 2D graphics, images or vector data.


For a computer, these two data types are totally different, one is a grid of pixels with individual colors, and the other is a series of points and curves.

For each one we use different software with different tools. Some illustration or photo manipulation software can edit bitmaps, while graphic design or font editing tools can edit vector data, but there isn’t a tool system that can edit both data types without changing contexts.

If we look at 3D assets, things get a bit more complex, as there are more ways to represent objects in 3D space. 3D objects can be represented by meshes with vertex attributes, meshes with texture detail, curves, distance fields and many more. Each representation has its own advantages and disadvantages, but there is no universal solution.


Current software that can handle multiple 3D representations, usually have different modes or toolsets adapted for each different data type. With Uniform, we want to create a single set of tools that works with all types of 2D and 3D data.


Let’s go back to 2D graphics for a moment, and let’s imagine we have this star-shaped 2D graphic. For some reason, we want to change its color to yellow.


The first information we need to know is “what kind of data is this?”. If it is a pixel based image, we have to open it in an image editor. If it is a vector drawing, we will use some vector editing software. Also, the steps we need to follow are completely different in each case. For an image, we have to select our yellow color and then use a bucket fill tool to change all pixels at once. If we are working on a vector drawing, we have to search for the stroke/fill properties and change the color there.

In both cases, we have our data (an image or vector graphic), and we have a specific tool that will perform a certain action only on that type of data.

Let’s try to simplify this process. Instead of using tools to manipulate pixels or vectors directly, we are going to insert a new object here designed to understand high level concepts like “color fill”. This object will be responsible for translating all high level actions into steps needed to edit each data type.


If we want to change the color of this new object type, we don’t have to worry about using multiple tools, workflows and pipelines for each data representation. The automatic translation will perform the right steps to edit the underlying data type.

With this new translation system in place, all we need is a powerful editor to handle our high level actions. This is the fundamental concept behind Uniform. The editor provides a set of high level tools that are internally processed to work on all supported data types.


Uniform’s UI and tools may not match what you would expect in other 3D software. Our toolset does not assume you are going to be working exclusively on meshes, and this is reflected in the UI and the naming conventions. As an example, the “remesh” action you can find in many sculpting tools has been turned into the “Surface Rebuild” high level action. This action will perform a typical remesh when editing a high poly mesh, but will be translated into the corresponding actions in other data types.


This new design allows us to expand Uniform’s capabilities much more efficiently. When adding new tools, they will be compatible with all supported data types, sharing the same UI and core functionality, without any extra development work. At the same time, we can add support for more data representations by simply adding new translators. As those translators work on high level actions, all the previously developed tools will become available on the new data type. The core set of high level tools is already working on high poly and textured meshes, and we plan to add more tools and new data representations in the future.


Uniform Objects

Now that we understand this let’s focus on what is inside a Uniform object and what you can do with it.

We are going to use as an example a really simple data type. Let’s imagine we have a data type that represents a bunch of building blocks. We want to edit it.

The first thing that we might want to do is change the color and material of each block. We are going to call this surface component operations. Operations that affect the surface components of the object are the ones that modify the properties of materials, colors, textures and high frequency details.


Another thing we could do is make the blocks larger or smaller. This fits in the deformation component operations.Other deformation operations could be squeezing the whole thing, changing the size of individual blocks or rotating the whole structure..


We also might want to change how blocks are organized inside the object without affecting its appearance, such as splitting a block in two or merging blocks that have the same color. We call this layout component operations.


We can also organize the blocks into different sets and then hide or split them into separate objects, these we call region component operations. Regions can also be used in combination with other tools to limit or control their effect.


As you saw, all these sets of operations related to a visual aspect of an object, in Uniform, are called components. This is what the tool system and UI will use for editing objects. Uniform UI won’t refer to vertices, edges, pixels or voxels directly, it sticks to these high-level visual concepts that can be translated to any kind of data you want to edit.

Finally, the output data after the translation step is defined by the object type. Let’s now see all of this in action.

Uniform in Action

Here we have two objects of different types, this means that the actions performed with the tool will translate to different data outputs. On the left, we have a GeoMesh object, which will translate the tool actions to a high poly mesh as commonly found in typical sculpting software. On the right, we have a PolyMesh object, which will translate it to a low poly mesh with detail represented as textures, useful for creating game ready assets or other applications that need to render the asset in real time.

As you can see, Uniform is using the same brush (which is a surface component tool), to paint both objects. The brush behaves exactly the same. Any settings, alphas or stamps you configure within it will work on all object types. There are no modes, workspaces or 5 different painting tools you have to configure individually. In Uniform, you use the same tools for all supported data types.

Next is a surface displacement brush. As expected, in a GeoMesh object, this will behave the same as in any high poly sculpting software. But in the PolyMesh object, Uniform will translate this operation directly to the normal map. You can use it to add surface detail to low poly models and skip the high poly and baking part of the workflow if you want to. This shows how Uniform’s tool system can simplify workflows that used to require many steps down to a single one.

Uniform objects also support layers for rendering their surface. Now we are adding a fill layer and painting its mask using the PolyMesh object. Having fill layers is common in a texture based 3D painting software. Uniform will translate this procedural fill layer to the high poly object as well, using the exact same UI and tools.

Because all Uniform objects are the same when it comes to tool operations, it means that we support multi object editing out of the box, even across data types. Here you can see how you can paint a texture and a high poly mesh with the same brush, same stroke. You can for example use this to deform or color correct all objects at once in a complex scene.

Uniform Features

As you saw, Uniform capabilities are defined by the translators (or object types) each version has. The initial release has the following object types:

  • GeoMesh : Object type for working with high poly meshes with per vertex colors and materials, fully compatible with other high poly sculpting software. You can use this for detailed VFX assets, 3D printing or geometry processing and cleanup.
  • SubdivGeoMesh: A GeoMesh variant for working with subdivision level sculpts, including detail propagation of vertex colors and materials.
  • PolyMesh: object that supports poly modeling and retopology. It can be used for creating game ready assets, texture painting, normal map editing and pixel art.
  • Image: object for editing 2D textures without being attached to a 3D mesh.

We also have other object types such as light fields, environments and scene graphs that cover other common functionality of 3D pipelines.


We built Uniform with a translation layer at its core, without sacrificing features or performance.

Uniform supports common features for asset creation such as color and sculpt brushes, including stamps, alphas and VDM. Color and displacement layers, procedural layers with masking, procedural geometry, instancing, topology editing… running through the translation layer and compatible with all the supported object types.

On top of that, Uniform was built from the ground up to make full use of modern hardware architecture features and optimizations. Its tools and rendering APIs use GPU coherent memory. Its surface kernels and layer compositor are fully GPU accelerated. Thanks to this, Uniform performance can be several orders of magnitudes faster than specialized 3D editors, even when running tools through the translation layer. You can use Uniform to edit very high poly meshes without any lag, like running operations on the entire model, such as filters or large texture alpha stamps.