Official DOTS Development Status And Next Milestones - December 2021

0.5 is released 2 Years ago
Maybe Unity should have made the version number 0.51, otherwise people actually look for 0.5 and find an old version.

 

So I hope you, GamesResurrected, see the irony in this. You complain about people who complain about a "confusing" version scheme, and then you fall for it yourself. I had a good laugh here. And now, since so many people receive an email notification, they can have it too. I said already this thread is comedy. And it gets even better. Thanks for that.

 

That's not 0.5, that's 0.5.0

Let's all just agree to call the upcoming version 0.quīnquāgintā so there's no confusion.

 

I'd just like an update on the release schedule of 0.50.
When they said Q1 I expected 31.3.2022.
With 5 weeks away, they could at least confirm it.

 

Sure, I meant releasing it "publicly" ..

How?

 

OMG, when will they find the time to release 33 more versions?

I mean, we can assume at this point that they will miss that deadline.

Rumor has it they got into a huge debate internally about the versioning scheme and they are now trying to figure out how to announce that the next version will actually be called "nulla punctum quīnquāgintā".

 

There is nothing to clarify. There are two sets of people here:
- who read the manual
- who are too lazy to read the manual

https://docs.unity3d.com/Manual/upm-semver.html

 

OMG, what you do not understand. Not all versions are released to the public, and probably are used as internal releases. Everyone there is a change in package that is significant enough version is changed. For instance there could be version 0.18 that worked with some changes in dependant packages like burst or jobsystem.

 

Yes, obviously, they announced that they will a release a 0.50 version months ago, because they knew the needed exactly 33 more versions (internal or not) to achieve their goals and NOT because 0.50 sounds like it's half way to a 1.0 release and that's what they want to communicate.

But please, let's spend MORE pages on the versioning scheme of DOTS version zero point half-way-there and pretend that it's not arbitrary.

 

So you're telling me that they knew before hand, months ago, they needed exactly 33 releases and 50 was NOT arbitrarily chosen because it's a round number that shows a lot of progress and looks like it's halfway there to 1.0.

K.

Unity should be really worried that the most interesting thing about their tech is its versioning style.

 

The 0.50 is correct, the ignorance from everyone who is learning about semver just now is only adding to the derailment of the thread here.

 

Yes, the "ignorance" is the problem. Not the people correcting other people for saying "wrong" things...

Everyone understands exactly what .5 means in the context of this thread, but some cannot resist the urge to "educate" everyone else anyway.

Seems relevant: https://xkcd.com/1576/

Again, Unity has really missed the mark here. Judging from this thread, the thing most interesting about their DOTS tech is the way they number their releases.

 

Holy hell. Take a look at this thread it's no wonder Unity doesn't reply to you guys anymore. This is the stupidest conversation I've read on the internet in years.

Please stop being baited. If someone keeps saying stupid things just stop responding - click their profile and click ignore.

 

ENOUGH discussion about versioning. If it confuses you then I recommend RTFM. It is off topic, and any further comments on this topic will be deleted, and that poster will lose the ability to participate in this thread.

 

The games I've worked on which used deterministic lockstep were veeeery CPU heavy, but they were RTS games with thousands of entities in the simulation. Though I would expect the performance lost by having to restrict some SIMD operations would be nothing compared to the performance requirements just to try to serialise the game state, let alone the bandwidth needed to send it.

 

A general question: If we convert GameObjects like "Light" to an entity, does its resource cost reduce? Can we convert features like: Heavy Rendering like HDRP, Ray-Tracing and hefty stuff to entities/ecs to make the game so efficient so it doesn't need a top-tier GPU to run? Or does DOTS only affect CPU & RAM usage and utilization?

 

Also, if GPU is not supported, is it in the roadmap plan for 1.0?

I see it as a huge boon to support GPU out-of-the-box. Massive and heavy rendering games that require powerful GPUs would run on lower-end devices more smoothly. CPU & RAM are supported, so why not also GPU?

 

I think you're misunderstanding what DOTS, or generally what Data Oriented Design, is. I strongly recommend you take a minute to google it and see what it entails. It is not a purely Unity design practice for code.

To start ya off, here's an excerpt from Wikipedia I believe is fairly succinct.

> In computing, data-oriented design is a program optimization approach motivated by efficient usage of the CPU cache, used in video game development.

If you wish to know what advantages this form of CPU design may offer for GPU image processing, I recommend you also take a look at the new *extremely* experimental API being previewed in the current Unity beta version. It's so bleeding edge that even I'm hesitant on touching it but it does promise great and deep advantages in graphics rendering with a more data centered code design.

 

IMHO, DOTS is actually learning how to process data fast from GPU. The code is similar to shader, which is both doing something in a pipeline way, handling many objects with similar operations at the same time.

 

No?

The mathematics library is shader like in some aspects, but that is not something inherent to data oriented patterns.

 

I have some interesting questions regarding the next DOTS releases:

1. Is there a performance increase/jump from 0.17 to 0.50?
2. If so, is there Yet Another performance increase/jump from 0.50 to 1.0?

 

I'm also wondering whether performance for handling few entities (dozens, not thousands) has been improved with 0.50+. As far as I remember, there was still an overhead that could have been reduced in future versions.

 

I have no insight on what migth or migth not be in 0.50 but hopefully :
- burstable struct base system support has been improved, reducing the main thread system overhead
- the enable/diable component feature, if it's part of the release, would allow to reduce strucural change synchpoints.

That's the 2 big things I see for performance improvments, more specifically for ECS rather than DOTS but all packages could benefit from it.

 

Will DOTS 0.50 support multiple lights? It is a crucial piece that makes or breaks visuals in oh so many types of games

 

Multiple light support is going to subject to the render pipeline you choose. Not really a DOTS feature

 

Well multiple lights for URP in DOTS requires deferred, which requires 2021, which DOTS doesn't support currently. So currently for universal its just one directional light along with semi broken baked lights.

 

I'm on 2021.2.12 with HR and Entities, everything looks fine for now. Of course, it's not recommended or supported but for me, it's working.

 

Glad its working for you, but animation wont work on 2021, dspgraph wont either, and Unity wont accept your bug reports.

 

Well, I consider Hybrid Renderer to be a part of DOTS, and Hybrid renderer currently does not support Additional Lights.
Direct qoute of Unity employee:
"Hi. Universal RP + hybrid currently does not support more than the main directional light. We have to make some new systems to pass the per object light index list through to renderer. This is high on our priorities and being worked on." That was 2 years ago...
https://forum.unity.com/threads/no-lights-when-using-hybrid-renderer-0-4-2.873376/

Deferred (URP) would be awesome but forward should support it too.

 

Any update?

 

@LaurentGibert I hope your bosses allow you communication.

Whatever the dispute is in your teams, PLEASE communicate.

 

There will be a 0.50 launch then there will be a 1.0 launch. Nothing has changed, even if the thread has lots of people commenting. It does take a long time to do good software though.

 

Nothing changed but the planned release date for 0.50 is almost due. At this stage, UT could at least confirm or postpone it.

 

I wouldn't be surprised if an update comes on March 31st, the last day of the first quarter. In any case, I'll be happy as long as it does come out in this first quarter as planned

 

No more release date speculation. It is clogging up the thread. Wait like adults.

 

Or just say, "hey, we are working in XX feature trying to solve YY problem, next post next week".
It takes less than 5 minutes a week and would reduce the anxiety, the feeling of abandonment of the thread and even reduce the amount of off-topic posts.

(Again and again, look at the "future of .net.." thread. Even if the real progress on the task is super slow, there's almost no off topic nor frustration on the entire thread. Why? cuz unity staff make small posts on a weekly basis (or less).)

 

I was referencing "larger and more detailed communication at the beginning of 2022" which is due, ?

see also https://forum.unity.com/threads/your-sticky-documentation-post.1247953/ .

I'm about to endeavour into DOTS again and I would like to not redo anything again.

Also this forum is treated seriously wrt bug reports from Unity devs, right? Beacuse at least regatrding the Input System I have the impression it's not.

If Unity thinks it needs more time to sort itself out that is fine.
But afterwards communication would help.

 

Best wait for 1.0 as the incoming 0.50 has breaking changes between 0.50 and 1.0.

 

I came back to Unity after 2 years and landed on this thread to try and see what is going on with DOTS. I have to say it is incredible how it's still not production ready. How are you guys even making money to support development for 2 years if nobody can make games with it. Oh well, see you all in another 2 years I guess.

 

UT has become a publicly traded company. So I guess the stockholders are funding development now. But on the other hand this money is used to buy other companies for billions of dollars. I don't know what's going on but it has not much to do with game development any more. Sadly.

 

There will be DOTS Q&A on March 23 https://www.twitch.tv/unitytech



There are 2 other DOTS presentations at GDC https://schedule.gdconf.com/search/dots but with "Viewing Experience: In-Person".

I think 0.50 might be released during GDC with the Unity's New Flagship Demo. There are also 2 "special sessions". Small chance as there were no updates here but who knows... I guess DOTS have to be at least mentioned in the new roadmap.

 

I've noticed GDC talks have interesting descriptions .

Unity's New Flagship Demo is rather hdrp graphical demo.
Other new game sample is made using 2021 LTS (wait we dont have lts yet) so it won't use dots.

DOTS Authoring and Debugging Workflows in the Unity Editor:

The path to leveraging DOTS in production:

 

Disappointing to wait this long for this. I wanted a DOTs only Unity and this sounds like that idea has been abandoned, even though the best received piece of the DOTs debacle was Project Tiny and that was DOTs only. From the beginning Unity should have split DOTs into its own thing from the ground up. Imagine where we’d be now.

 

Still waiting on stable build of DOTS only and worst off as over half of unity doesn't work with unity. Having hybrid build let's game development be done with dots while it still is in development. Tbh I think if Unity went DOTS only editor we would just now be getting the first preview of Dots. Supporting 2 engines increase the strain on personnel resources.

 

even hybrid way is invisible

 

While I agree that Tiny is great for small projects, it is still of interest only to a really small fraction of Unity users. For the vast majority, being able to use DOTS for parts of their game requiring speed such as streaming and moving a lot of things is much more important than a pure Tiny solution.

At this very moment you can add Entities to your project, convert your CPU heavy code to parrallel jobs and gain performance. That's a pretty nice thing. Hybrid rendering, once it supports light probes and basic features of its kind, will be a game changer too.

I hope Tiny still lives tho as I can see a lot of benefits to it for the web and smartphones development.

 

I see an update button but I am scared to click on it.
Is there any official announcement on it?

 

The change log isn't up yet - I'd wait for that at least.

 

I just tried to upgrade it in a Test Project and it won't upgrade due to some packages not being released yet (Platforms 0.50 in this case) which causes the upgrade to fail. So we just have to wait a bit longer!

 

For those wondering...

Spoiler: 0.50 Changelog

[0.50.0] - 2021-09-17
Added

• Window > DOTS > Entities window to show all Entities in a world in real time, with ability to search, select each, and inspect it via the Inspector.
• Window > DOTS > Components window to show all Component types, with ability to search, select each, and inspect it via the Inspector.
• Window > DOTS > Systems window to show all Systems running in a world, categorized by System Group, with ability to search, select each, and inspect it via the Inspector.
• Introduced two new ECS specific Window > Analysis > Profiler modules: * Entities Structural Changes profiler module can record which world/system produced a structural change, and how much time it cost per frame. * Entities Memory profiler module can record which world/system allocates memory chunks, with additional details per archetype.
• ArchetypeChunk.GetComponentDataPtrRO() and ArchetypeChunk.GetComponentDataPtrRW() provide unsafe raw access to a chunk's component data, as a lower-overhead alternative to ArchetypeChunk.GetNativeArray()
• ComponentTypeHandle.Update() allows ComponentTypeHandles to be created once at system creation time, and incrementally updated each frame before use.
• Adds clearer message when TypeManager hasn't been initialized yet, instead of only reporting a component type we don't know about has been requested.
• Disabled entities in Entity Window now have the same style as the disabled gameobjects in the gameobject hierarchy
• Go-to button to update Inspector content to reflect selected system and highlight the system in the Systems window if there is one open.
• It's now possible to specify an alignment when allocating an array with BlobBuilder
• Upgraded to burst 1.5.2
• Added go-to buttons to update Inspector content to reflect selected component and highlight the component in the Components window if there is one open.
• Routines to create unmanaged systems on worlds were made available for public use
• It's now possible for a scene to contain weak asset references to other scenes and prefabs. All referenced scenes and prefabs will automatically be included in a player build. The sample in "EntitiesSamples/Assets/Advanced/WeakAssetReferences" shows how to use weak asset references to scenes and prefabs.
• Incremental conversion now tracks GameObject names to rename Entities when they change.
• New method CanBeginExclusiveEntityTransaction on EntityManager to check whether or not a new exclusive entity transaction can be made.
• Wrapper functions are added in CollectionHelper to create/allocate NativeArray from custom allocator
• Entities.ForEach() will now accept a lambda with no parameters.
• WithSharedComponentFilter now also works with two shared component parameters.
• EntityCommandBuffer has an IsEmpty property, which returns true if at least one command has been successfully recorded.
• TryGetComponent in ComponentDataFromEntity
• TryGetBuffer in BufferFromEntity
• Entities journaling, which can record ECS past events and inspected from the static class EntitiesJournaling properties.
• Allow for easier viewing of EntityCommandBuffer within an IDE through a new debug proxy.
• Within an EntityCommandBufferDebugView, each command will have a summary of the action performed before expanding the command.
• SystemRef.Update to allow updating unmanaged systems manually.
• Support WithScheduleGranularity with Entities.ForEach to allow per-entity scheduling
• EntityCommandBuffer.Instantiate() can now instantiate more than one Entity in a single command, writing the resulting entities to a NativeArray<Entity>.
• Support for fully-bursted Entities.ForEach.Run in ISystemBase systems.
• RateUtils.VariableRateManager to facilitate update rate
• DefaultWorld.BeginVariableRateSimulationEntityCommandBufferSystem
• DefaultWorld.VariableRateSimulationSystemGroup
• DefaultWorld.EndVariableRateSimulationEntityCommandBufferSystem
• Element EnableBlockFree is added to enum WorldFlags to indicate whether World.UpdateAllocator is enabled to free individual memory block.
• ComponentTypes has a new constructor variant that takes a FixedList128Bytes<ComponentType>, suitable for use in Burst-compiled code.
• EntityCommandBuffer has several new variants that target a NativeArray<Entity>, which may be more efficient in many cases than recording individual commands for individual entities.
• New Archetypes window that can display current archetype memory usage.
• IJob* types use SharedStatic so they can be burst compiled eventually
• Add ability to add missing partials during generation if DOTS_ADD_PARTIAL_KEYWORD scripting define is set.

Changed

• Added a fast path for IJobEntityBatch.RunWithoutJobs() and IJobEntityBatchWithIndex.RunWithoutJobs() where query filtering is disabled, resulting up to a 30% reduction in performance overhead.
• Merged com.unity.dots.editor package into com.unity.entities package, effectively deprecating the DOTS Editor as a standalone package. All the DOTS Editor package functionality is now included when referencing the Entities package.
• DOTS Runtime now uses source generators for codegen.
• Make parts of EntityPatcher burst compatible to prepare for burst compilation of EntityPatcher for its performance improvement.
• Entity.Equals(object compare) now returns false if the compare object is null, rather than throwing a NullReferenceException.
• Made DynamicBuffer an always blittable type (even in the Editor with safety checks on), so that it can be passed by reference to Burst function pointers.
• BlobAssetStore.ComputeKeyAndTypeHash hash calculation reduced chance of collision
• Capped the maximum number of previewable GameObjects to 100 in the Entity Conversion Preview.
• Capped the maximum number of additional entities shown to 250 in the Entity Conversion Preview.
• Improved overall performance of the Entity Conversion Preview.
• Source generators are now used as the default mode of codegen for Entities.ForEach and Generated Authoring Component. These can be disabled with SYSTEM_SOURCEGEN_DISABLED and AUTHORINGCOMPONENT_SOURCEGEN_DISABLED scripting defines if necessary. The largest change is that generated code can now be inspected and debugged (when not bursted). Generated code lives in Temp/GeneratedCode and can be stepped into with both Visual Studio and Rider.
• Documentation to highlight necessary prerequisites in the Build Configuration for making a profilable build.
• Entities window now shows prefab entities with a style similar to the one in the GameObject hierarchy
• Systems in the Entity inspector relationships tab are now sorted by scheduling order instead of creation order.
• Subscene headers are now loaded asynchronously and will no longer stall the main thread while loading.
• Performance of LiveTweaking has been improved.
• EntityDiffer capture entity changes when only entity's name is changed.
• With an IDE debugger, EntityQuery will present more information related to it. The raw view
• Debugging output for a ComponentType will present clearer info.
• The batchesPerChunk parameter to IJobEntityBatch.ScheduleParallel() has been replaced with a new ScheduleGranularity enum. Pass ScheduleGranularity.Chunk to distribute work to worker threads at the level of entire chunks (the default behavior). Pass ScheduleGranularity.Entity to distribute individual entities to each worker thread. This can improve load balancing in jobs that perform a large amount of work on a small number of entities.
  *Make generate linker xml files deterministic in order.
• Within an IDE debugger, ComponentSystemGroup will present more relevant information. The raw view will be available for those who need the precise makeup of the class.
• ComponentSystemGroup.RemoveSystemFromUpdateList and ComponentSystemGroup.RemoveUnmanagedSystemFromUpdateList can now be used when ComponentSystemGroup.EnableSystemSorting is set to false
• Add debug checks to detect "placeholder" Entities created by one EntityCommandBuffer from being passed into a different EntityCommandBuffer.
• Clarified error message when calling .Dispose() on an EntityQuery created by GetEntityQuery(). This is always an error; these queries belong to the associated system, and should never be manually disposed. They will be cleaned up along with the system itself.
• Within an IDE debugger, ArchetypeChunk will present more relevant information. The raw view will be available for those who need the precise makeup of the struct.
• Within an IDE debugger, EntityArchetype will present more relevant information. The raw view will be available for those who need the precise makeup of the struct.
• IJobEntityBatch batchIndex parameter has been renamed to batchId. Documentation regarding what values to expect from this parameter have been updated accordingly.
• Changed: Within an IDE debugger, EntityManager will present more relevant information. The raw view will be available for those who need the precise makeup of the struct.
• Changed: Within an IDE debugger, an ArchetypeChunk's OrderVersion and ChangeVersions per ComponentType will be easier to view.
• Changed: Within an IDE debugger, SystemState will present more relevant information. The raw view will be available for those who need the precise makeup of the struct.
• Changed: Within an IDE debugger, World will present more relevant information. The raw view will be available for those who need the precise makeup of the struct.
• EntityCommandBufferSystem.CreateCommandBuffer() now uses the World.UpdateAllocator to allocate command buffers instead of Allocator.TempJob. Allocations from this allocator have a fixed lifetime of two full World Update cycles, rather than being tied to the display frame rate.
• EntityCommandBuffer.AddComponentForEntityQuery<T>() now asserts if the provided T value contains a reference to a temporary Entity created earlier in the same command buffer; these Entities are not yet correctly patched with the correct final Entity during playback. This patching will be implemented in a future change.
  *Removed ComponentSystemBaseManagedComponentExtensions.HasSingleton{T} - ComponentSystemBase.HasSingleton{T} already handles managed components.
• ISystemBase to ISystem
• New Query Window design.
• FixedRateUtils renamed to RateUtils
• IFixedRateManager renamed to IRateManager
• Records in the EntitiesJournaling feature now have OriginSystem that will be populated for which system requested the change. This information is helpful to determine where a deferred EntityCommandBuffer was recorded from.
• Improved diagnostic when a SubScene section entity does not meet one of the constraints during GameObject conversion.

Deprecated

• In a future release, IJobEntityBatch.RunWithoutJobsInternal() and IJobEntityBatchWithIndex.RunWithoutJobsInternal() will be removed from the public API; as the names indicate, they are for internal use only. User code should use the non-Internal() variants of these functions.
• Several public functions in the EntityDataAccess have been deprecated. The new functions follow this convention DuringStructuralChange(...)
• Entity Debugger has been marked as deprecated and will be removed in a future release. See new windows under Window > DOTS.

Removed

• Deprecated functions in the EntityCommandBuffer for EntityQueries that were processed at Playback.
• GI Light baking in Closed SubScenes for now to remain consistent with Entity mesh renderers.
• Unity.Entities.RegisterGenericJobTypeAttribute has been moved to Unity.Jobs as Unity.Jobs.RegisterGenericJobTypeAttribute.
• StreamBinaryReader and StreamBinaryWriter are now internal
• Removed JobComponentSystem. It has been replaced by SystemBase, which it much better tested and supported. The Entities 0.5 upgrade guide explains how to upgrade from JobComponentSystem to SystemBase.
• IJobBurstSchedulable
• Job reflection data ILPP

Fixed

• Fixed a minor typo when generating the name of a conversion World.
• [DisableAutoCreation] is no longer inherited by subclasses, as documented.
• Improved the Entity inspector responsiveness.
• In Burst 1.5.0, fixed some player-build warnings that were caused by some entities code that contained throw statements not within [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")] guarded functions.
• Performance of system safety checks greatly improved
• Systems window, Entities window and Components window all use the same minimum size.
• Systems window style issue in minimum size.
• Incremental conversion issue where children of disabled gameobjects are not properly re-enabled when parent is re-enabled.
• Fixed multiple inspectors issue with Entity Inspector where contents are duplicated in the existing inspectors.
• Fixed multiple inspectors issue with System Inspector where only the latest inspector has content while the rests are empty.
• We now use the TypeCache in TypeManager when initializing, which is about twice as fast as previously.
• Sometimes redundant error messages were logged, now fixed
• EntityQuery methods which limit their processing to a specific NativeArray<Entity> now work correctly if the EntityQuery uses chunk filtering.
• Certain code paths of IJobEntityBatchWithIndex were not storing the per-batch base entity indices at the correct byte offset.
• IJobEntityBatchWithIndex.ScheduleInternal() did not always work correctly with EntityQuery chunk filtering and limitToEntityArray both enabled.
• The variant of IJobEntityBatchWithIndex.Run() that took a limitToEntityArray parameter no longer asserts.
• IJobEntityBatch was redundantly applying chunk filtering at both schedule-time and execute-time.
• EntityCommandBuffer no longer leaks embedded entity arrays whose commands are never played back.
• Methods that take an EntityQuery now validate the query's validity.
• Add missing bounds checks for EntityManager methods.
• A ComponentSystemGroup that disables automatic system sorting no longer sets its "sort order is dirty" flag on every update.
• EntityQuery.SetSingleton<T>() will now throw an exception if the query only requested read-only access to type T.
• EntityQuery.GetSingleton<T>() and EntityQuery.SetSingleton<T>() now assert if T is a zero-sized component, avoiding a potential out-of-bounds memory access.
• Creating an EntityQuery with a non-empty list of None types will now match return a reference to an existing query if possible, instead of always creating a new query.
• EntityCommandBuffer playback of *ForEntityQuery() commands no longer leaks AtomicSafetyHandle allocations when collections checks are enabled
• Memory leak in BlobAssets when a World was disposed that had BlobAssets. Primarily seen when entering and exiting Playmode in the Editor.
• XXHash3 could potentially throw exceptions if Burst compilation was disabled. This is no longer that case.
• variant checkbox in GhostAuthoringComponent inspector was disabled if no variants for that component were present, not letting the user select the DoNotSerialize variation.
• SendToOwner not handled correctly by the client. Now both server and client do not send/receive the component only if the ghost present a GhostOwnerComponent.
• Baked lightmaps for SubScenes will no longer appear black due to lack of compiled shader features
• Clamp compute shader support detection to disallow GL < 4.3
• If you update multiple packages, create a new section with a new header for the other package.
• EntityDiffer no longer patches BlobAsset or Entity references from UnityEngine.Object types.
• Debugging of source-generated Entities.ForEach
• Some main-threads EntityCommandBuffer methods were missing the necessary safety checks.
• StructuralChangeProfiler should now have the proper scope when making changes through the EntityCommandBuffer and EntityManager.

[0.19.0] - 2021-03-15
Added

• Usage of RegisterBindingAttribute through [GenerateAuthoringComponent] when the user opts in to using Sourcegen
• Names assigned to entities are now available by default in all builds, not just within the Editor. To strip Entity debug names from builds, define DOTS_DISABLE_DEBUG_NAMES in your project's build configuration.
• The package whose Changelog should be added to should be in the header. Delete the changelog section entirely if it's not needed.
• Added support for loading entity scene headers asynchronously (disabled by default).
• IJobChunk, IJobEntityBatch, IJobEntityBatchWithIndex, and IJobParallelForDefer now have ByRef() versions of all .Schedule() and .Run() methods. These should be used in cases where the corresponding job struct is too large to pass by value to the existing methods (~10KB or larger). Functionality is otherwise the same as the existing methods.
• Unmanaged EntityQueryDescBuilder allows Burst code to construct entity queries
• Entity debug names will be disabled by default in release builds. The new build component "Enable Entity Names" can be added to a release build configuration to re-enable these names, if the application has some use for them.
• SystemRef<T> and SystemHandle<T> offer a way to keep track of unmanaged systems
• Update com.unity.properties and com.unity.serialization to 1.7.0
• (EXPERIMENTAL) A new scripting define (UNITY_DOTS_DEBUG) enables a subset of inexpensive API validation and error handling in standalone builds.

Changed

• Updated platform packages to 0.12.0-preview.8
• Manual testing, repro fixed
• Renamed LiveLink view modes (Under DOTS Menu in the Editor) to something more clear. DOTS->Conversion Settings:
• New version of Roslyn compiler to enable source-generator features.
  *Burst compatibility tests added for EntityQueryManager + EntityQuery
• When DOTS_DISABLED_DEBUG_NAMES is enabled, EntityCommandBuffer.SetName will have minimal overhead.
  *Cleaned up many uses of UNITY_2020_2_OR_NEWER, UNITY_DOTSPLAYER, UNITY_DOTSRUNTIME, and NET_DOTS
  *Added StableHash to EntityArchetype, which represent an archetype stable hash calculated from the component types stable hash.

Deprecated

• SceneBundleHandle.UseAssetBundles is deprecated. It no longer had any use and was never meant to be public.
• EntityQuery.CompareQuery() with managed EntityQueryDesc. Use the variant that accepts an EntityQueryDescBuilder instead.
• WordStorage,NumberedWords, and Words are marked for deprecation, as these storages are not recommended for public use.

Removed

• Removed struct FastEquality.Layout.
• EntitiesBurstCompatibilityTests has been removed and placed into the Entities test project.

Fixed

• Enabling a hierarchy would sometimes fail to create a child array on the parent entity.
• Fix entities not rendering past -32785 units on the X Axis.
• Issue with StorageInfoFromEntity which causes exception due to incorrect Read access permissions to the Entity type
• Blob assets built with BlobBuilder should now always be properly aligned.
• Missing 'catalog.bin' file on Android when building a DOTS game with SubScenes.
• BlobAssetReferenceData did not implement IEquality interface which could result in BlobAssetReference comparisons to fail even though the underlying data pointers are the same.
• If you update multiple packages, create a new section with a new header for the other package.
• Added missing closing braces for suggested fixes in ComponentSystemSorter warnings
• scene streaming will no longer raise a NullPointerException if a previous load failed due to an error.
• EntityCommandBuffer.AddComponent() for managed components no longer triggers a double-dispose on the component.
• Fix issue where no timing information was displayed for struct systems in the entity debugger
• Struct systems implementing ISystemBaseStartStop now don't receive double stop notifications
• SDF fonts are now rendered with correct anti-aliasing on WASM

Removed/Deprecated/Changed

• Each bullet should be prefixed with Added, Fixed, Removed, Deprecated, or Changed to indicate where the entry should go.

[0.18.0] - 2021-01-26
Added

• Toggle support
• The package whose Changelog should be added to should be in the header. Delete the changelog section entirely if it's not needed.
• AddSharedComponentForEntityQuery(EntityQuery, T) and SetSharedComponentForEntityQuery(EntityQuery, T). Both methods 'capture' the set of entities to modify at record time, not playback time.
• BufferAllocatorVirtualMemory for virtual memory backed allocations of fixed size buffers.
• BufferAllocatorHeap for heap backed allocations of fixed size buffers.
• EntityCommandBuffer methods for managed components that perform a query at record time (instead of at playback time): AddComponentObjectForEntityQuery and SetComponentObjectForEntityQuery.
• Added new method GetEntityQueryDesc to EntityQuery. It can be used to retrieve an EntityQueryDesc from which the query can be re-created.
• Support for adding HybridComponents in conversion using DstEntityManager.AddComponentObject(). Support is limited to built-in types provided by Unity already, and not custom components.
• standalone builds by default opt out of using entity debug name storage. When opted out, EntityManager.GetName will return a default string, and EntityManager.SetName is a no-op. To override this default and include debug names in standalone builds, define DOTS_USE_DEBUG_NAMES in the Player "scripting defines" field.
• EntityCommandBuffer.SetName, allowing users to set a debug name on an Entity created from EntityCommandBuffer.CreateEntity
• GameObjectSceneUtility.AddGameObjectSceneReferences() that can be used in custom Entity Bootstrap code to ensure currently loaded Game Object Scenes are added as references to the GameObjectSceneSystem for cases where these scenes were loaded without the GameObjectSceneSystem (eg in the Editor and pressing Play).
• New StorageInfoFromEntity struct which allows reading information about how an entity is stored (such as its ArchetypeChunk and index inside of the chunk), from within a job. You can also use StorageInfoFromEntity to check if an Entity exists, or if it has been destroyed.
• ConcurrentSectionStreamCount & MaximumWorldsMovedPerUpdate can now be set on SceneSectionStreamingSystem in order to tweak the throttling of scene section streaming

Changed

• Sample scene now has text that updates based on toggle state.
• EntityCommandBuffer.ParallelWriter no longer throws when recording on the main thread. (The throw was added to prevent 'improper' use, but there's nothing actually harmful about recording to an ECB.ParallelWriter on the main thread.)
• Updated platform packages to 0.11.0-preview.10.
• BufferAllocator which selects between BufferAllocatorVirtualMemory or BufferAllocatorHeap, depending on platform capabilities.
• improved performance of EntityManager.SetName() and EntityManager.GetName()
  *Added EntityManager.GetName(FixedString64)
  *Added EntityManager.SetName(Entity, out FixedString64)
  *Fixed an issue where passing an invalid or deleted Entity into EntityManager.GetName or EntityManager.SetName would result in a valid operation. The functions now throw an ArgumentException if the Entity is invalid.
• EntityManager.GetName() returns the relevant string containing "ENTITY_NOT_FOUND" when the given Entity does not exist in the World
• AssetDependencyTracker is now faster when there are multiple async artifacts pointing to the same guid
• ResolveSceneReferenceSystem has a fast path for instantiated entity scenes (eg. for scene tile streaming)
• Update minimum editor version to 2020.2.1f1-dots.3
  *Updated platform packages to 0.11.0-preview.11
  *Updated properties package to 1.6.0-preview
  *Updated serialization package to 1.6.2-preview
• Updated com.unity.burst to 1.4.4
• EntityQuery methods (.ToEntityArray(), .ToComponentDataArray(), and .CopyFromComponentDataArray()) distribute their work across multiple worker threads for sufficiently large workloads.
• EntityScene now relies on a new File format that reduces copying of memory while deserializing
• The constructor of MemoryBinaryReader now takes the length of the memory block and checks for out of bounds reads
• BinaryReader and BinaryWriter interfaces now have a Position property that can be set to seek within the stream
• Performance of ResolveSceneReferenceSystem is improved
• Improved performance of EntityQuery.IsEmptyIgnoreFilter, GetSingleton(), GetSingletonEntity(), and SetSingleton() for infrequently-changing queries.

Deprecated

• The EntityCommandBuffer methods which perform an EntityQuery at playback are now deprecated. Instead use the methods whose names end with "ForEntityQuery". These "ForEntityQuery" methods perform the query at 'record time' (when the method is called).
• GameObjectConversionSystem.AddHybridComponent()
• StreamBinaryReader and StreamBinaryWriter have been deprecated and will no longer be part of the public API. Please provide your own implementation if you need it.

Removed

• Removed deprecated GameObjectEntity.CopyAllComponentsToEntity, EntityManager.Instantiate(GameObject), GameObjectConversionUtility.ConvertIncremental, ScriptBehaviourUpdateOrder.UpdatePlayerLoop, ScriptBehaviourUpdateOrder.IsWorldInPlayerLoop and TypeManager.TypeCategory.Class
• Removed these expired deprecated APIs: EntitySelectionProxy.EntityControlSelectButtonHandler, EntitySelectionProxy.EntityControlSelectButton, EntitySelectionProxy.EntityManager, EntitySelectionProxy.OnEntityControlSelectButton, and EntitySelectionProxy.SetEntity
• Removed expired APIs ArchetypeChunk.BatchEntityCount
• Removed expired fixed time step APIs ComponentSystemGroup.UpdateCallback, FixedStepSimulationSystemGroup.MaximumDeltaTime, FixedRateUtils.EnableFixedRateWithCatchup/EnableFixedRateSimple/DisableFixedRate
• Removed expired Frozen component
• Removed expired GameObjectConversionSettings.Fork method and GameObjectConversionSettings.NamespaceId field
• Removed expired EntityGuid.NamespaceId field
• Removed expired GameObjectConversionUtility.GetEntityGuid method

Fixed

• TargetGraphic field in toggle and button now converted
• Removed various testing components from the entities package from the Add Component menu.
• EntityQuery's matching chunk cache could briefly become stale in some cases.
• Inspecting an invalid entity in the inspector will no longer throw an exception.
• If you update multiple packages, create a new section with a new header for the other package.
• Rare issue with SubScenes left visible in a Scene they were not present in anymore (Editor only)
• StableTypeHash for UnityEngine.Object component types to not collide when the same typeof(myObjectType).FullName is present in multiple assemblies loaded in the editor.
• Fixed potential out-of-bounds memory access when changing a chunk's archetype in-place.
• Fixed a bug where the same name assembly loaded in the editor could result in the EntitiesILPostProcessor throwing an ArgumentException due to duplicate keys being used to add to a dictionary.
• SceneSystem.GetGUID would fail to match equivalent file paths with lowercase/uppercase mismatches.
• Ensure warning against using systems with [ExcludeAlways] does not trigger with versions of Unity including and after 2020.2.
• Fixed an issue where precompiledreferences defined to an empty array [] in .asmdef files would potentially throw errors in the buildprogram on OSX machines.
• You can now debug the contents of BlobAssetReference<T>
• Removed excessive warnings due to incompatible fields not being able to be inserted into the BindingRegistry
• You can now group conversion systems and process after load systems by marking their parent groups with the corresponding WorldFilterFlags
• EntityDebugger no longer hides worlds with duplicated names
• A bug where EntityQuery.IsEmpty did not respect change filters being modified in pending jobs when Job Threads are used
• Entities are now written to YAML in the order that they appear in a chunk
• A NullReferenceException when using IJobEntityBatch after calling EntityManager.DestroyEntity(EntityQuery).
• EntityManager.GetCreatedAndDestroyedEntities() no longer returns ChunkHeader entities in the new entity list.
• Fixed a bug where streaming in scenes instantiated multiple times with multiple sections and references between those sections, entity ids wouldn't get correctly remapped, thus we would reference entities in a different scene / tile
• Chunk.SequenceNumber (Internal API) is now guranteed to be unique when deserializing a chunk from disk. SequenceNumbers are used in internal world diffing methods to detect changes.
• Fix GetSingletonEntity() HRV2 error when destroying all the entities in the EntityManager
• Compilation error when removing the built-in module Particle System
• AutoLoad disabled on SubScenes works correctly again
• Regression where an entity could not be renamed multiple times.
• Fixed Entity inspector throwing when a dynamic buffer is removed from an inspected entity.
• Tiny.UI "Hidden" computation fixed.
• EntityManagerDebugView now also displays meta entities (for chunk components) and shared components.
• using BlobBuilder in generic methods no longer raises a safety error
• Many methods that use IJob were marked as [NotBurstCompatible] to reflect their true Burst compatibility.

Removed/Deprecated/Changed

• Each bullet should be prefixed with Added, Fixed, Removed, Deprecated, or Changed to indicate where the entry should go.

[0.17.0] - 2020-11-13
Added

• ISystemBase interface for making struct based systems that allow Burst compiling main thread update
• New UnsafeBufferAccessor struct that permit to un-typed and unsafe access the dynamic buffers pointers.
• New ArchetypeChunk.GetUnsafeAccessor public API that allow to retrieve dynamic buffers unsafe accessors using DynamicTypeHandle.
• safety check in DynamicComponentDataArrayReinterpret that throw an ArgumentException if used to access the component data for IBufferDataElement type
• ComponentSystemBase.TryGetSingleton
• ComponentSystemBase.TryGetSingletonEntity
• Tests for Tiny.UI transformations.
• Added documentation for incremental conversion and dependencies
• New scheduling API for IJobEntityBatch which limits the resulting batches to an input NativeArray<Entity>
• BlobAssetStore. AddUniqueBlobAsset. A much simpler approach to managing blob assets during conversion. BlobAssetComputationContext continues to be the recommended approach for scalable blob asset generation.
• UnsafeUntypedBlobAsset gives a non-generic untyped blob that can be created and later casted to a specific BlobAssetType. This can be used for storing multiple types of blob assets in the same container.
• GameObjectConversionSystem.IsBuildingForEditor returns true when building data that will be loaded by the editor (As opposed to building data that will be loaded by the standalone player). This can be used to strip out editor only debug data.
• GameObjectConversionSystem.BuildConfigGUID returns the GUID of the build config that is used by this conversion context
• Tiny.UI support for 9-Slice (including sprite sheet support)
• DynamicSharedComponentHandle and related methods for accessing shared components without compile time type information.
• The public static method EntitySelectionProxy.CreateInstance was added. It creates, configures, and returns a valid instance of EntitySelectionProxy.
• The public static method EntitySelectionProxy.SelectEntity was added. It creates, configures, and selects an instance of EntitySelectionProxy, without returning it.
• All the public properties and methods of EntitySelectionProxy have been documented.
• Tiny.UI support for text alignment
• Tiny.UI support for multi-line text
• TypeManager will now store whether or not an ISharedComponentData is managed or unmanaged.
• EntityScenesInBuild class that allows registering EntityScenes that are generated via a custom asset importer into the build. This is used by the Environment system to generate streamable tile data that is generated procedurally from tile inputs.
• New EntityCommandBuffer methods that affect a set of entities matching a query. Unlike existing methods, these new methods 'capture' the entities from the query at record time rather than playback time: the array of entities is stored in the command, and then playback of the command affects all entities of the array. The methods are AddComponentForEntityQuery(EntityQuery, ComponentType), AddComponentForEntityQuery(EntityQuery, ComponentTypes), RemoveComponentForEntityQuery(EntityQuery, ComponentType), RemoveComponentForEntityQuery(EntityQuery, ComponentTypes), DestroyEntitiesForEntityQuery(EntityQuery).
• EntityManager.Debug.GetEntitiesForAuthoringObject and EntityManager.Debug.GetAuthoringObjectForEntity. They provide a convenient API to map game object authoring & entity runtime representation.
• New ComponentSystemGroup.EnableSystemSorting property allows individual system groups to opt out of automatic system sorting. PLEASE NOTE: Certain system update order constraints are necessary for correct DOTS functionality. Disabling the automatic system sorting should be only be a last resort, and only on system groups with full control over which systems they contain.
• Entities.WithFilter(NativeArray filteredEntities) allows for filtering with a set of specific entities in addition to the EntityQuery requirements
• Added Live Conversion debug logging to more easily see what is reconverted (enable from the menu DOTS/LiveLink Mode/Incremental Conversion Logging)

Changed

• Update burst to 1.4.1.
• Improved the performance of ILPostProcessor type resolution.
• ProcessAfterLoadGroup is now public. This group runs after a subscene is loaded.
• Unity.Transforms systems now use IJobEntityBatch instead of IJobChunk. Expect modest performance gains due to the new job type's lower scheduling overhead, depending on the workload size.
• When DOTS/Live Link Mode/Live Conversion in Edit Mode is active in 2020.2 or later, conversion is now incremental
• Removed deprecated Entities.ForEach.WithDeallocateOnJobCompletion. Please use Entities.ForEach.WithDisposeOnCompletion instead.
• Fixed livelink patching for BlobAssetReference<T> fields in managed components and shared components.
• Updated package com.unity.platforms to version 0.9.0-preview.15.
• TypeManager.Equals and TypeManager.GetHashCode performance has been improved when operating on blittable component types.
• BlobAsset and entity patching for managed IComponentData & ISharedComponentData now use an early out if the class is known to not contain any blob assets or entity references
• Managed class IComponentData now supports patching of entity references in EntityCommandBuffer.AddComponent.
• Improved EntityManager.GetCreatedAndDestroyedEntities performance by introducing an internal entity creation / destruction version number that is used to early out when calling GetCreatedAndDestroyedEntities
• TypeManger.TypeInfo.Debug has been removed. TypeName has been moved directly into TypeInfo and renamed to DebugTypeName.
• Nested or variant prefabs used in a scene now correctly trigger reimports on subscenes when the parents parent prefab changes
• Update minimum editor version to 2020.1.2f1
• EntitySelectionProxy was streamlined to ensure that its usage does not override inspector locking behaviour and respects the Undo / Redo stack. With the new workflow, there is a 1:1 relationship between an Entity and its EntitySelectionProxy. Static utility methods were added to support this new workflow.
• Rename TypeManager.IsSharedComponent to IsSharedComponentType and add IsManagedType
  *Enabled generic systems to be instantiated in non-tiny dots runtime
• Updated platform packages to version 0.10.0-preview.1.
• Made SystemBase/JobComponentSystem classes partial in preparation of use of Roslyn source generators for code-generation (more to come).

Deprecated

• Forking of GameObjectConversionSettings is no longer supported
• The public delegate EntitySelectionProxy.EntityControlSelectButtonHandler has been deprecated.
• The public event EntitySelectionProxy.EntityControlSelectButton has been deprecated.
• The public method EntitySelectionProxy.SetEntity has been deprecated.
• The public method EntitySelectionProxy.OnEntityControlSelectButton has been deprecated.
• The public property EntitySelectionProxy.EntityManager has been deprecated. Use EntitySelectionProxy.World.EntityManager manager instead. This change was made to remove boilerplate checks in the code.
• Deprecated Frozen component as it is no longer in use

Removed

• Removed deprecated proxy component types. CopyTransformToGameObject, CopyTransformFromGameObject and CopyInitialTransformFromGameObject now use [GenerateAuthoringComponent] instead.
• Removed expired EntityManager.IsCreated API
• Removed expired API to compare EntityManager to null (EntityManager is a struct now)
• Removed deprecated types and methods: NativeArraySharedValue<S>, implicit EntityQuery conversion to null, ComponentDataFromEntity.Exists and BufferFromEntity.Exists, ArchetypeChunkArray.GetComponentVersion, IJobEntityBatch.ScheduleSingle, IJobEntityBatch.ScheduleParallelBatch, EntityManager.LockChunk, EntityManager.UnlockChunk, World.AllWorlds, World.CreateSystem, all GetArchetypeChunkX methods, EntityCommandBuffer.ToConcurrent and EntityManager.CreateChunk
• ComponentSystemBase.ExecutingSystemType has been removed. With the introduction of unmanaged systems, this information has been incorrect. Furthermore, there cannot be a static global property for this since multiple worlds might execute at the same time. If you need this information, consider passing it manually.

Fixed

• Wrong query and check in ACS_DynamicComponentDataArrayReinterpret
• Fixed ICE (internal compiler error) thrown when storing into a field in reference type in bursted/scheduled lambda.
• EntityQuery.ToEntityArray will work when temp memory is passed in an a parameter for allocator
• EntityQuery.ToComponentDataArrayAsync and EntityQuery.CopyFromComponentDataArrayAsync will throw errors if user tries to use Temp memory containers.
• Hybrid Component Lights flickering when LiveLink edited.
• Fix crash when using singleton access methods with types with generic arguments.
• Code generation for indexers in structs with [BurstCompatible] attribute.
• Fixed potential JobHandle leak if an exception was thrown while scheduling an IJobForEach.
• Fixed that DynamicBuffer.RemoveAtSwapBack only copied the first byte of its element data
• Updating the shadow world via the EntityDiffer is now using Burst
• The 'New Sub Scene' menu item is no longer missing in the 'Create' drop down of the Hierarchy .
• Overwriting Sub Scene file when creating new Sub Scene no longer logs an error but instead overwrites the user selected file.
• Fixed livelink patching for BlobAssetReference<T> fields in managed components and shared components.
• Fixed entities getting lost during LiveLink when moving GameObjects between multiple subscenes
• Deprecated call to UnityWebRequest.isNetworkError in Unity.Scenes.FileUtilityHybrid
• Generic jobs now get reflection data generated in more cases
• Generic jobs will always work to schedule in editor (but may require attributes in Burst scheduling cases)
• Selecting entities in the Entity Debugger window will now respect the locked state of the inspector.
• several bugs where writing EntityBinaryFiles was not resulting in deterministic files. It is now guranteed that if entities are constructed in the same order, it will result in the same binary exact file.
• Fixed a case where LiveLink would sometimes leave dangling entities when a scene is opened and closed repeatedly
• TypeManager.InitializeAllComponentTypes no longer uses DateTime.Now, which can be very slow in players
• Structural changes right after scheduling a job in a SystemBase no longer crash a player
• Sorting a ComponentSystemGroup now correctly sorts any child groups, even if the parent group is already sorted.
• The subscene inspector no longer allows you to unload section 0 if another section is still loaded, and it also disallows loading any section before section 0 is loaded
• EntityManager.CopyAndReplaceEntitiesFrom no longer fails when the Entity capacity of the destination is larger than the capacity of the source
• Hybrid components on disabled GameObjects are now also converted
• Children of a nested Parent not updating LocalToWorld if Parent's LocalToWorld was changed by a custom system with an archetype containing a WriteGroup for LocalToWorld
• EntityQuery APIs which take an input NativeArray<Entity> for filtering (such as ToEntityArray()) can now be called with ReadOnly NativeArray<Entity> without throwing an exception.

Upgrade guide

• managed class IComponentData now supports patching of entity references in EntityCommandBuffer.AddComponent. This can result in a significant performance regression if there might be an entity on the managed component when playing the command buffer. If a managed component has a reference to another class that is not sealed it is unprovable that there may or may not be entity references on it. Thus we have to walk the whole class data to apply it. If there is in fact no entity reference on a class referenced from a managed component, then it is recommended to mark the referenced class as sealed, so that the type manager can prove that there is no entity references present on the managed component and thus completely skip all relatively slow entity patching code.

Edit
Official change log available: Changelog | Entities | 0.50.0-preview.24
Upgrade guide: Upgrading from Entities 0.17 to Entities 0.50