Proposal: Explicit Management of Data Blocks and (possible) Deprecation of Fake User

This proposal is intended to provide a unified vision for multiple changes necessary for the introduction of explicit data management in Blender and eventual deprecation of the controversial Fake User workflow.

The Fake User workflow has been a significant pain point for a large portion of the Blender community throughout the entire history of Blender’s existence. Despite this history being over a couple of decades-long, the Fake User workflow has failed to prove itself as a superior, or at least comparable alternative to more conventional data management workflows found in other CG-related software. If anything it’s proven itself to be worse.

My proposal for addressing the entire issue is comprised of four major steps, which are only going to be effective if they are all implemented together, as lack of any of these steps will negate the effectiveness of all the other steps.

  1. Categorizing datablock types into two categories, Persistent and Expendable, based on user expectations.
  2. Making changes to the datablock selector UI elements and Renaming the Fake User feature to “Mark as Persistent”.
  3. Adding “Data Manager” mode to Asset Browser
  4. (Optionally) Removing dependence of editors on viewport selection

1: Categorizing datablock types into two categories, Persistent and Expendable, based on user expectations:

One of the most important factors in getting this right is acknowledging the existence of such things as common user expectations. They are not a myth. There are many different examples of CG software out there that save some types of data even when the data is not referenced by any aspects of the scene while discarding others. Yet, userbases of these software packages do not seem to be longing for an ability to to manually determine how different types of data is discarded nearly as much as Blender userbase is longing for not having to make this determination manually.

When searching for the source of these expectations, it appears that the categorization of persistent versus expendable data types is mostly based on whether the given data type has its dedicated editor, or whether the data type can be edited only inside the viewport. It appears that whether it is conscious or not, the users generally expect the data, which are editable exclusively in the viewport to be expendable as soon as they are gone from the scene (deleted, not just hidden).

Applying the following logic to the plethora of Blender’s datablock types, we arrive at something like this:

  1. Marked Green are the datablocks I am fairly certain to have their distinct place for creation and editing.
  2. Marked Orange are the datablocks I am fairly certain can only be edited/interacted with in a viewport
  3. Marked Yellow are the datablocks I was not certain about. I could not find for sure if they are the type of datablock someone would want to store for later use.

Since Blender indeed has quite a lot of unique datablocks, while I would suggest generally using the logic above as the reference for categorization, I am not sure it would be wise to do this categorization all at once. I propose to start at the current state of Blender, where all datablocks are considered expendable, and gradually start moving the most obvious candidates into the persistent category. I would start with Materials, Images, Node Trees, Textures, Text, Masks, Palettes, Scenes, Worlds, and Sounds.

Datablocks present in the “Persistent” category would never be automatically discarded by Blender.

2: Making changes to the datablock selector UI elements and Renaming the Fake User feature to “Mark as Persistent”.

I will be using the material datablock selector UI element as an example below since losing materials seems to be by far the most common example of fake user workflow shortcomings. But I expect the equivalent changes to be applied to all datablocks. (For example, renaming “New Material” to “Duplicate Material” would be handled by an equivalent change in the node editor, not renamed literally the same).

A: The fake user button would be removed from any Persistent datablock selector UI elements:
The Persistent datablocks will always be saved, no matter what. There must be no element present in the UI, which could cast any doubt on this holy rule:

B: The “New Material” button would be renamed to the “Duplicate Material” button:
Since the premise of this proposal is that users will now be explicitly in charge of the data management, we need to make any data-related operators as clear as possible. We can not lie to users by labeling a feature such that it implies the creation of the new datablock with default data, when what it actually does is make a copy of the currently selected datablock with all its modified data.

C: The “Unlink data-block” would be renamed to “Clear data-block slot”:
At the first glance, this may sound like a synonym. One could argue that the meaning does not change. The issue here is that the “Unlink” word carries a bit of scene data dependency connotation, and idea of breaking the link therefore implies some modifications to the scene dependency structure. This connotation is valid in most of the areas where Blender uses datablock selector UI, but not in all of them. A good example of where it can introduce a bit of uncertainty is the Image Editor:

When user gets into a situation of UV mapping a textured object, it’s not often uncommon requirement to temporarily disable display of the texture in the UV editor, especially if the texture has strong visual features, making the topology of the UV map hard to see. At this point, if the texture displayed in the UV editor is the same as the texture on the 3D object itself, the wording “Unlink” can introduce a degree of uncertainty of the result of the action.

It’s not immediately clear if clicking the button will affect just the UV editor viewport display, or break some data link on the object itself, such as unlinking texture from the material. The user’s uncertainty is justified, since in case of the Shader Editor, that’s what the button would do.

Renaming the operator to “Clear data-block slot” would make the description of the operator still valid in cases where actual data links between the scene data blocks are broken, but would make the operator less worrisomely ambiguous in cases where what’s being broken is just a link between the datablock and the editor editing it.

This leaves us with the elephant in the room. Two options, both having pros and cons. It would be up to the community which outcome they prefer:

D1: The Fake User button would be kept on any Expendable datablock selector UI elements, and renamed to “Mark as Persistent”:
The naming of the Fake User feature itself has always been at the center of the Fake User workflow controversy. It was confusing to new users unfamiliar with the Blender jargon, and in such a critical area as data management and possible data loss, confusing nomenclature just can not be excused.

Since this proposal introduces self explanatory concepts of Persistent and Expendable datablock types, functionality of which can be inferred by the naming itself, renaming the “Fake User” function to “Mark as Persistent” would alleviate one of the main pain points.


  • Users could choose to keep around certain Expendable datablocks, which aren’t generally excepted to be kept around, such as mesh. You could have the flexibility of keeping a mesh in your .blend file without the mesh being used by any object present in the 3D scene.
  • It’s a partial defeat and makes the whole solution less elegant. If Camera and Light datablock types was moved from Expendable to Persistent category, we would have “Mark as Persistent” button on all expendable datablocks while it would probably really make sense to use it only on meshes and only in very rare, creative scenarios.

D2: The Fake User button would be removed altogether:
Going with the “If it can only exist and be edited in the 3D scene, not another editor, and is not present in the 3D scene, it should be discarded” philosophy would allow to remove the Fake User button completely.

  • Very clean and elegant solution. The users are freed from the chore of explicitly marking the data blocks they don’t want to be discarded.
  • You can not choose mesh datablocks to not be discarded.
  • Controversial in terms of datablocks like Camera or Light. If we deem Cameras and Lights to be Persistent datablocks, then users will have cleanup duty to manually, explicitly delete Light and Camera datablocks created by lights and cameras which were created in the scene at any point in time. If we deem Cameras and Lights to be Expendable datablocks, the users will lose the ability to store Light or Camera properties without having Lights or Cameras present somewhere in the 3D scene.

3: Adding “Data Manager” mode to Asset Browser:

While thanks to the concept of Persistent datablock types, users no longer need to anxiously worry about most of the datablock types they create in Blender disappearing because they forget to explicitly click a button, they now also receive a new duty of cleaning up these Persistent data blocks themselves.

Right now, with the tools Blender has available in its current state, this duty would more often than not feel like a frustrating chore, and perhaps even a step back for some of the users who have learned to utilize the burden of Fake User workflow to their advantage. Only tool Blender currently has for explicit datablock management is the “Blender File” mode of the Outliner editor. This tool is insufficient as a means for effective explicit datablock management.

Thankfully, in recent versions, Blender has introduced Asset Browser, which provides a solid basis for extending it into an effective solution for creation, management, editing and deletion of Persistent datablocks.

Asset Browser would gain “Data Manager” mode:

In the Data Manager mode, user would not have any option to change or rename the folder structure of the datablocks. In the similar way to how Blender uses predefined folder structure when appending datablocks from other .blend files:

…the Data Manager mode would simply display a list of all the Persistent datablock types on the left sidebar:

Upon selection of any of the datablock type on the left sidebar, the Data Manager simply lists all the datablocks of the given type stored in the file:

Right clicking selected datablock(s) would present user with convenient context menu crafted for most common datablock management operations:

Right clicking empty area in any datablock type will present user with an option to create new datablock of given type:

Blender has a great “Maximized View” overlay functionality, which can open any editor in a temporary for overlaying everything with a quick “Back to Previous” button, which closes the overlaid editor and returns user back to his workspace. This can be utilized perfectly here. Double clicking any datablock in the Data Manager window would open the double-clicked datablock in an overlay editor, giving the user ability to view/edit it immediately. For example double clicking the material would immediately open it in a overlay editor with a quick way to exit it:

Double clicking most of other datablock types would open them in their appropriate editors, if they have any, for example:
Action->Action Editor
Image->Image Editor
Mask->Image Editor
Material->Shader Editor
Geometry Nodes->Geometry Nodes Editor
Text->Text Editor

Lastly, of course, we still need to make the actual clean up of the unused data easy for the user. For this purpose, I will take a liberty of expanding on the idea by Harley Acheson: ⚙ D14030 UI WIP: User-Managed Unused Data

The Data Manager would get a single button, functionally similar to “Clean Up Recursive Unused Datablocks” operator.

Once clicked, it will spawn a pop up window listing all the Persistent datablocks without any users in the scene with checkboxes, allowing the user to determine which ones to keep and which ones will be discarded:

This new cleanup operator with the confirmation list of datablocks to be removed would also replace both Clean Up → Unused data-blocks and Recursive unused data-blocks in the File menu. Therefore, it would be accessible both from the File menu as well as Data Manager.

So when it comes to managing accumulation of the Persistent datablocks in the scene, all it takes now is to open the Data Manager from time to time, click a single button, review all the datablocks to be removed, uncheck those user wants to keep, and click remove. Unlike the current cleanup operator, you will actually know what you will be removing before it happens, which is quite important.

The last thing on the table for the Data Manager proposal are D1 and D2 options from the step #2. If it was decided to go with D1 option, and keeping the ability to Mark Expendable datablocks as Persistent, the Data Manager would also have to show the categories for Expendable datablocks on the left sidebar. In this case, I would propose to show Expendable datablock types only if the given Expendable datablock category contains at least 1 existing Expendable datablock which has “Mark as Persistent” flag enabled.

4: (Optionally) Removing dependence of editors on viewport selection:

The convenient ability to just double click any datablock in the Data Manager and having it immediately opened in the appropriate editor in overlay mode is currently a bit tricky to do, because for the most part, Blender ties editing of the certain datablocks to viewport selection. There is a pin button in the Shader, Geometry Nodes and Image editor, allowing to temporarily decouple the contents of the editor from the active viewport object, but it’s very limited and insufficient.

I will be using Shader Editor in this example, but these changes would once again apply to all the editors working in the similar manner.

Current way things work in regards to editing datablocks cause multiple issues:

  • It’s not possible to edit unassigned material. If you want to edit material which is currently not assigned to anything, you have to create a new temporary object, such as cube, assign the material to it, edit it, and delete the temporary cube. The pin button does not suffice here as while the editor is in the pin mode, it does not allow you to change which material is being selected.
  • In the similar manner, if you want to edit material which is used in the scene, but object can not be selected, because it has disabled selectability, for scene management purposes, you need to temporarily make the object selectable just to edit its material. That should not be necessary.
  • In a quite unexpected and confusing manner, the datablock selector in some of the editors, such as Shader Editor, is actually an instance of the active slot on the selected viewport object. While common sense would assume this datablock selector works in the same way as it does in the image editor (it select the data block the editor is currently editing), in Shader Editor the datablock actually changes the material assigned to the given slot on the mesh. This often leads to a lot of frustration from both new as well as experienced users. It’s very difficult to get used to due to this behavior changing between different editors in the very same software.

I propose a new paradigm: Changes in the datablock editors, such as shader editor, should only be able to change the state of the datablock they are editing, not the parent objects which utilize the edited datablock.

Here’s how it will work in practice:

The default mode of the Shader Editor gets rid of the Slot selector and Pin button:

…and the datablock selector in the shader editor will no longer be affecting which material is assigned in the active material slot on the active object in the viewport. Instead, the datablock selector will be selecting the material which is currently being edited, in the same way Image Editor datablock selector does.

This allows users to edit any material at any time, without need to create temporary objects to put unused materials on before editing. It also reduces the issues where user accidentally changes the material assigned on the object by intending to just edit another material.

However, this does not mean that the idea of synchronization between the active objects and the editor is wrong. It was just executed wrong, and it can be done better:

In place of the Pin button, the Shader Editor will gain synchronize button, similarly to the one which can already be found in the UV Editor:

When this button is activated, the material currently edited by editor is synchronized with the material in the active slot of the active object. This is similar to current behavior, but has some key differences:

  • When the sync mode is activated, the datablock selector is gone. What determines which material is edited is now the active material slot of the active object. So users can no longer accidentally change the material on their object. Assignment of the materials should not be done by the datablock editor, but by the object editor (properties panel).
  • In the sync mode, the datablock selector is replaced by the Slot selector, which was removed from the “main” mode. This means that users using the sync mode can still change which of the materials assigned on the active object they are editing, even if they currently do not have the material tab of the properties editor available in their workspace, and do not need to leave the editor area to do so.

I believe this can give us the best of the both worlds. We can gain the ability to easily edit any datablock we want, regardless of what’s selected in the viewport. At the same time, we can still enjoy the benefits of the synchronization between the editor and active viewport objects, while eliminating the confusing and inconsistent behavior of some editors having ability to modify datablock assignments.

5: Stretch Goals:

Ability to drag and drop datablocks directly from the Data Manager onto compatible datablock selectors across the UI would be nice :slight_smile:

If you managed to get through this entire wall of text, you have my admiration :slight_smile: Thank you for reading.


Ok so I read that whole proposal and it looks super solid! Great work. It’s what I was envisioning for an elegant solution. A couple questions for you:

  1. How does this proposal address concerns by some (@1D_Inc Paul comes to mind) that having data-blocks be persistent could lead to scene bloat? In that on Team projects there would be uncertainty around cleaning up unused data for fear that it may be deleting something than another artist intended on keeping. What are your thoughts on that?

  2. Could the shader editor and other similar editors support visualizing materials on temporary stand in objects, or could an existing mesh be used temporarily as well, to facilitate visualizing the material itself?

  3. Could this change the naming of users to something more accurate such as link?

  4. Could the number of links listed now be corrected so that if the first option was used and individual items could be protected those items that were unused would have 0 links. As it currently stands, if an item is unused but protected with fake user, it lists that item as having 1 user, even though it has zero, and just has a fake user. Aka, store protected state in another property and don’t attach it to anything.

Overall amazing work and I want to help implement and refine this however I can!

I clearly see the motivation for this, and I would love for example that some parts such as materials would be independent elements of the meshes or objects. Although some parts seem to me to complicate the handling of blender a lot more than just understanding the fake users.

The parts that I really like

  • calling the fake user persistent data (the name is self-explanatory)
  • Being able to separate materials from the selected object in the node editor (I’ve been asking for this for a decade, I see difficult to change it).

The parts I don’t understand

  • The data manager. That is, we already have access to all this information currently in the outliner. I see no reason to have to put all this part, which is quite clear that it belongs to the outliner, in a new section of the asset browser.
  1. Not all datablocks will be persistent, only those that make sense to be persistent. And there’s the “Cleanup Unused Data” feature near the bottom of the proposal. That will prevent the bloat.

It’s extremely simple. Once you notice the old data getting in your way when working, that’s when you click that one button to clean it up, and you are good to go. It just happens when you tell Blender to do so, not on its own.

Until you don’t notice the persistent datablocks are in your way, then they won’t be much of a bloat, unless you are packaging textures within your .blend file (which you should do only for purpose of sending it to someone else or archiving). That’s because their size in memory and on your drive is absolutely negligible. Textures (not packed within the blend file) are just stored path to the file on the drive and bunch of small metadata. Materials and node groups are tiny. So is Text, Action strips and so on. Packed textures aside, the other datablocks of considerable size are in the “Expendable” category, so they would be auto-cleared the same way they are now.

  1. Possibly, but that’s not related just making the data management explicit. It’s useful feature, but it’s not necessary for this.

  2. I am not sure that would help much. Possibly, but I don’t have a strong opinion.

  3. My proposal doesn’t expect that. It simply expect the user to completely forget about any concept of fake user that ever existed. In case of Expendable datablocks, user will just have a single toggle telling Blender “Treat this Expendable datablock as Persistent”, but that’s the extent of it. Users should not be burdened with checking references between the datablocks.


That’s because Outliner:

  • Doesn’t allow you to create new datablocks for within it.
  • Doesn’t allow you to open the datablocks in their appropriate editor when double clicking them.
  • Displays both Expendable and Persistent datablock types.
  • Displays redundant information, such as Window manager datablock.
  • Overall isn’t the best UI for managing data. Modern game engines, which usually manage a lot more data than average DCC software have proven that the content browser type data management workspace is better for this task than vertical tree like outliner. For example, the Data Manager mode could use the same code Asset Browser mode does for rendering thumbnails for material datablocks. So when managing your materials, you have visual reference instead of just list of names. I just did not add thumbnails example to my mockup.

I second the parts you like!

In regards to the data manager view, I disagree. I think it is crucial for blender to have this as a feature, regardless of the other three elements of the proposal. My reason being this:

As it currently stands the only view (I know of) of the data in the whole file is the blender file view in the outliner. This view is not sufficient to manage complex scenes with lots of data-blocks. In that it not only displays too little information, but it also doesn’t provide the tools to manage that data effectively like outlined above. Materials for instance in this view are difficult to manage having no previews etc.

An improvement in data visibility and management would be helpful now and necessary if certain data blocks were to become persistent.

Yup. I’m totally on board. I’ve read pushback to this in the other dev thread, and was curious to your take on it.

In my experience, literally no other application I’ve used, 3D or otherwise, discards data I expect it to save. Especially data that you put lots of time into (e.g. materials). So I really think it’s behavior around this should change. And I think what you’ve outlined above will fix those problems

  • Outliner could allow create new datablocks. In case that was necessary.
  • outliner could allow to open data block. If you talk about create new windows with the editor I think you can forget about that idea because it goes against the whole idea of blender UI and it will never prosper.
  • It’s not a problem. I don’t think you’re going to convince developers to make first and second class data blocks because you just don’t want to see a few more folders.
  • More redundant than creating a data manager that displays the same information as the outliner I don’t think.
  • I don’t agree, for several reasons, you are thinking about materials that are of little interest to have a thumbnail. The management of what you say is only interesting in small scenes, the moment you have many data blocks you will find yourself lost… that is assuming that they are going to make thumbnails of each element of blender, which I doubt it.
1 Like

This is by far one of the things that bugs me almost on a daily basis when working in Blender. Why on earth should we not be able to create and edit a material if not assigned to an object?? I mentioned this as the main reason in my proposal for having a new dedicated Material Library Editor: Right-Click Select — Blender Community

And I agree that the whole fake-user behavior, along with other data-blocks behaviors should be completely overhauled, it feels like in every release Blender is having new incredible technology for going to the moon, while keeping the main engine of an 1800s car.


@Alberto: I disagree with your reasoning for not having a dedicated datamanager on several of your points:

  • In general: the outliner (in Scenes or View Layer mode) shows usage of each single datablock in its context. It manages structure. The datamanager proposed by @LudvikKoutny manages lists of elements of various data block types: materials, nodegroups, textures, images, etc. The essence of the proposal by @LudvikKoutny (to me) is to visually decouple having a datablock of type x from using that same datablock.
  • If the outliner were to provide for creation or editing of datablocks of any type, it would have to break (or at least, bridge) the connection to a datablock’s context, same as what the datamanager would as in the proposal. As a question / an example: if you have a camera object selected in the Outliner and you create a new material, in which context would that datablock be created? Would it for instance automatically be an orphan, as Cameras do not have Material datablocks, and therefore be automatically invisible?
  • If the outliner could open a datablock for editing, it would in multiple use cases necessitate that the editor used is also disconnected from the context in the outliner, similar to the proposal.

I disagree that it is not a problem. I do run into difficulties with Blender’s current functionality.

  • While the Data API view of the Outliner does essentially give me lists of available datablocks per type, it does not allow editing of either properties or contents. That could be overcome in either your or @LudvikKoutny’s proposal. In either case, especially if working from the Data API view, the disconnection of both outliner and editor from usage context, as mentioned above, is required.
  • As an example: a use case I run into is to make the same edits to several materials: current Blender functionality stops me at two points: 1) I can only edit materials in use, 2) and I have to find and select each material separately through the structure in the outliner. Having a “list-based” view solves both problems for me. Having it in a view that resembles the Asset Browser, as @LudvikKoutny proposes, makes it more useful to me than having to use the Data API view.

Your reasoning that “developers cannot be convinced” seems to me to be beside the issue. The proposal seems to be written with users in mind, not developers. It does not change or break Blender’s data structure, nor does it change how many folders @LudvikKoutny gets to see, regardles of his wishes.

On a personal note: I invite you to help find solutions on the topic @LudvikKoutny tries to address, as you see them within the current structure of Blender. I also invite you to stay away from argumenting on or around the person of @LudvikKoutny, such as declaring what he encounters “not a problem” or making (in my view) rather disrespectful personal remarks on his reasoning.

Whether having few or many datablocks of a given type makes the solution @LudvikKoutny proposes “of little interest” or “will find him lost” seems to me to be of a similar vein. Please regard the problem stated, not the person stating it. If you disagree with the solution, help find a better one.

Your reasoning does not take into account that the outliner currently already displays datablocks outside the scene structure or viewlayer.

When I talk about what the developers will do I say it first because this is a development forum, in case you have not noticed, and then because the OP himself has a topic asking to be able to select simply through the meshes and need to put a button on the interface that proposal, even with the code written, has been waiting 4 years.

On Personal note: I don’t know who you are or what your comments about me are about, I don’t care what you think. Your cultural opinions do not interest me.

Huge proposal, looks complicated.
It is hard to define a practical need for creating blank material, since you have to assign it to an object to set it up anyway.

1 Like

With @finirpar comment in mind, could you explain the need for creating an orphan material?

That’s exactly why materials shouldn’t be treated as a second class data type. For example right now with Geometry Nodes I’ve seen many people doing tutorials were they create a “dummy” object just for the purpose of having materials assigned to it, so those materials can be referenced later on the node tree.
Wouldn’t be easier, faster, and more efficient if users were allowed to just have materials created, edited and managed independently from objects?


I second that. Materials and at least a couple other data types should be first class citizens. You should absolutely be able to create, edit and manage materials independent of objects.

I think this whole thing boils down to what is defined as an orphaned data-block aka non linked / referenced data-block. It seems right now, anything that isn’t currently being used in the scene is destined for the trash and needs selective protection to ensure it doesn’t get thrown away on close. So hence the reason for the current fake user (which really should be called something anyway) system.

I think the only reason this system makes sense (throw out anything not being used, and force the user to select what to save) makes sense for team projects where the files are worked on by a lot of different people, and where organization seems more difficult.

As a single user, for me it doesn’t make any sense, as I not only expect everything to stick around, but also I expect myself to keep things well organized.

If it were to stay, to help teams, it would need to be renamed to make sense and tooling built around it to ensure protections were easier to apply, checks were made before close to ensure the user had s chance to review and keep what they want.

Regardless, the whole concept of orphans and fake users has informed the design of other parts of the application that should get redesigned and have other editors added. Data management is lacking and needs s panel in the asset browser. The object dependent material creation and editing is clunky and relegates it to second class status. Basically there needs to be a revamp of a number of things regardless of how the garbage is dealt with, either automatically or manually.

And to that point. These systems could be revamped, added, and redesigned and have it be optional as to how you deal with the data. For teams the could keep the auto deletion in place, with added safety checks and data management features. For individuals, you could turn it to a manual setting where items would be protected by default. Either way it gives the user the flexibility to use Blender how the would like, and also give them proper tooling in both cases to manage it. It seems like there are people on both sides who like the different Workflows, so why not revamp what’s there, add proper tooling around them, and leave it up to the user?

What do y’all think?

From my experience it’s the exact opposite actually. When working on larger projects with multiple people, most of them will just adopt a habit of mindlessly clicking fake user button on everything, because they do not want to lose data. They usually do that because on larger projects, where more people are involved, the more is at stake.

So then, you often get a file which has tons of “fakeusered” datablocks, but you can’t just afford to unmark them and purge them, because you don’t know if the reason the other guy marked it as fake user was out of habit, or was actually valid because they need to use that datablock in the future, or perhaps they are using some script which assigns that datablock.

For example I myself have unused material in most of my scenes which is being assigned by a script which bakes curvature maps for procedural shading of models that go into the game engine. Once the texture is baked, the duplicate temporary baked object is deleted, so the material ends up unassigned again, but it’s still needed for the next bake. Making temporary copy of the object for baking is much safer than modifying the actual object and then manually reverting all the changes, hoping you did not forget anything.

I generally agree with rest of what you said, but I disagree that fake user workflow works better as the team size increases. It actually works even worse.


Not just for Geometry Nodes, actually. I work in a company where I have to assign and manage defined materials on many objects. I always need to have one dummy object open which holds any material from which I want to reference properties or shaders etc.
The closest (native) thing in Blender would be the ‘Blender File’ Browser but selecting a material from there doesn’t open its graph in the shader editor. You have to have an assigned object selected. It’s rather ridiculous, really.


Great feedback! I’ve never used it a team environment and so I was basing that assumption off someone else’s strong feedback around that usage. To your point, there’s nothing preventing users on a team hitting the fake user button anyway, so that argument for keeping it for team usage goes out the window as soon as someone goes ham protecting things.

So that just further’s the need in my mind that there needs to be better data management tooling built, and processes refined. So as to help in general. And for the fake user system to be scrutinized further for replacement by something better or removal.

I second that absolutely. The need for better tooling and process around that is very real.

Yes, pretty much this. That’s why I proposed data manager despite the fact we already have Blender File mode of the Outliner. We need something that’s actually dedicated, as well as better suited for the data management.

What I proposed as the Data Manager could be basis for something even more capable in the future. I don’t consider it to be just a different looking duplicate of the Blender File mode Outliner.

Data Manager is supposed to concerned only about Persistent datablocks, and its main purpose would be to actually manage them. Outliner on the other hand is concerned with all datablocks, regardless of Persistent or Expendable, and its main purpose would be simply to give you full information of what data the current Blend file in its current state contains.