URP vs standard render

that doesn’t make sense. You didn’t do render scaling or resizing? Because I tested with a simple project right now, only a terrain and a few cubes… and performance in mobile diffuse vs urp was light years ahead on the device.

 

Profile and see where the performance is going

 

I'm sure your problem is not related to the simple lit shader... I have used lit shaders without too much performance impact. Also i got same result on built-in pipeline
I have tested Standard and Diffuse shader on my terrain and the performance was the same using built-in pipeline between diffuse and standard shaders(above game demo , Redmi 9A)

 

I did. The shaders. They are taking most the memory and most the rendering time. That's why I can't understand how they say the performance is the same. I even just tested with a new project, clean. Added cubes, added a terrain and a directional light. Same results.

@UnityLighting in URP you are using the default terrain URP Lit shader? Because that uses PBR, so by definition is has to be slower than the standard terrain shader in built in. It´s just not possible that the PBR is faster or equal speed.

 

I have tested diffuse and standard in built-in ... The performance was the same
Also standard shader in built-in pipeline is pbr and it is same as Lit shader in urp
Simple lit is same as Blinn–Phong in built in (legacy specular)
The mali400 mp2 gpu has performance drop in standard shader. But my new device Redmi 9A has no any performance drop

 

Standard in built in for mobile is very slow.

Testing on only 1 device means almost nothing.

URP Simple Lit has all of frag in half precision. This may make a difference in older mobile devices where fixed precision does things.

Legacy Specular is much slower than mobile diffuse shader in built in. If Simple lit is the same as legacy specular, then it's slower than mobile diffuse.

Unity never had good mobile shaders (in fact this was a request a lot of us made in the 3.x to 5.x era).

 

I have tested on a lot of new devices... The shaders and post effects has no too much performance cost on the new devices even low end devices like Redmi 9A
Only old mobile gpus has too much performance lost when using post processing, HDR or pbr shaders. Unity knows this and has removed diffuse shaders from new versions. Also has removed GL Es2 and legacy post effects by default

Download my in game settings menu and check the performance cost of the post effects, bloom and HDR effects from here
Android APK

 

Oof.

 

Nobody is arguing the performance cost of bloom or post effects. Or even pbr in modern devices.

I am saying and I can prove it right now, that there is no way on earth that URP simple lit and urp terrain lit is faster than built in mobile diffuse with the previous terrain diffuse shader.

It is simply impossible because inside those URP shaders there is tons of new maths and code to the point that each of those shaders are over 30mb in ram memory in the device. It’s like saying that calculating exponentials a 1000 times is faster than adding 10 numbers. It’s just impossible. In modern devices you may not notice it much but in old android devices the different is extremely obvious. There is no way on earth URP shaders are of equal speed because it would defy physics. Just load the profiler and tell me that it’s not taking a crap load of ram memory on shaders and rendering time. Open source that project and I am sure I can modify it for standard pipeline to run at way faster the speed than URP and looking practically the same just changing the shaders.

 

You are free to use Unity 4 to have maxed our performance on old devices
As i remember, Traffic Rider and Real Drift games still using Unity 4 in the 3 years ago ( i'm not sure for now)

I am personally a fan of the built-in pipeline and Unity 4...
Unity 4 was the best for mobile development. But we have forced to use the latest version
You can still using built-in pipeline for the next few years
Unity 4 was the best... But it was and it is not
- Bake lighting in minutes
- Bake lightmaps into the prefabs out of the box
- Run editor as fast as possible (open, close, import, export, build)
- Bake result is same as realtime setup
- Maximum performance by default

 

Yeah, Unity 4 was the best Unity there was performance wise. After that it's been downhill in mobile performance. But we are talking in this thread about URP vs Standard and your statements don't make any sense to me. If instead of the apk you provide the project so that we can see what's done for the performance testing, we could see what's going on. Because, again, the way URP is designed it's mathematically impossible that the default URP Simple Lit and URP Terrain Lit are faster than the mobile diffuse shader. Hence my original question of if it is possible to write our own urp version of those avoiding all the pbr junk we don't need.

 

I have reviewed it in this video
I don't have time now but in the future I will compare the performance of the standard shader with diffuse shader in the standard pipeline
For now, I can only confirm that they made no difference in my game(standard terrain shader and diffuse terrain shader)
Goodbye

 

Man, that video doesn't review anything since the project is not open and it has all your asset store assets included in it. It's your sales pitch for your assets in the store! It's not a realistic comparison at all. There is no way to tell what settings are unless you share the project.

Again, it's super simple.

1) Create a new empty project for URP and for Standard. Add a terrain, add a couple of cubes and a directional light.

2) In standard, set the terrain shader to diffuse. And the cube shaders to mobile diffuse shader.
3) In URP set the terrain to the default terrain lit and the cubes to the URP Simple Lit.

4) Enable real-time lighting and shadows, nothing baked to make a realistic comparison.

5) Compare RAM and performance in the old android device. Use the profilers.

If URP is faster or consumes less RAM then your project settings are wrong. Share that project and I'll make it go faster in standard pipeline every single time in any Unity version. It's literally more than double the FPS in an old android device and with much fewer RAM requirements.


Here is a screenshot of the memory profiler on my device. The LARGEST RAM by far is taken by a single shader, the URP Simple Lit shader. And shader stripping is set on and all optimizations are enabled. It takes more RAM than all my 3d assets and unity engine combined. You are saying that shader is faster or similar speed than Mobile diffuse shader in the standard pipeline which has almost no math and even ran on OpenGL 2.0. You do realize how impossible that statement is right?




Now compare this with my regular game fully loaded with all textures in built-in. As you can see 21 shaders in memory takes less that 1/10 of the memory of a single shader in URP and Mobile Diffuse is 2 to 3 times faster in the profiler than URP Simple Lit.

 

Not claiming URP is not slower, but there are holes in your test description:

- A default project using built-in uses gamma rendering, URL is linear.
- URP has some integrated post processing enabled by default while built-in doesn't have any post processing whatsoever unless you add them yourself either by a package asset, or roll your own.
- The increased memory usage has no relationship with rendering performance: the URP shader stripping algorithm is terrible and generates a lot of useless shader variants, but when actually rendering only one variant is used for each render pass even though all compiled variants are loaded in memory.

If you want to get to the bottom of why one is slower than the other, you should grab the appropriate GPU debugger for your device and use it to capture and profile a frame. This way you'll be able to see exactly what both built-in and URP are doing to render a frame, and see how much time each step is taking.

Even without a debugger, there are ways to determine what the bottlenecks are:

- Delete all objects and test a scene with nothing in it except the camera. Any differences in this scenario are likely to come from differences in post processing and/or linear/gamma/HDR/LDR.

- Add your objects, disable shadows, then set the resolution scale so the game renders at a tiny resolution like 8x8. Performance differences in this scenario are going to come from how efficiently the CPU is used to setup the frame for rendering plus. Vertex shader performance might make a difference of you have too many triangles. Enabling shadows allows you to compare performance in updating the shadow cascades.

- Add only one object and make it cover the entire screen. Performance differences here will come from the shader used. Pixel shader cost is directly proportional to how many pixels are rendered using that shader.

 

I didn't go into all the details of the setup, but set them up equality. I use linear and no post processing. Make it as barebone as possible and compare. URP is never faster in mobile if you are using simple shaders with no post processing and a single directional light+real time lighting. That is the way it is. I was hoping at least to get it close enough, but right now the difference is huge.

I already used the GPU debugger on two devices and same thing: the URP shaders are about 300% slower than mobile diffuse in my two test devices. If you get newer devices, the difference is not as large but as soon as you begin adding more shaders and content it becomes pretty apparent even in last generation devices. Specially because even if the GPU can keep up, the RAM does not because the automatic shader stripping is working horribly in URP as of the latest official version (adding a couple of URP shaders can put it up to 500mb of RAM only in shaders!).

As of today, in mobile, performance is not even close once you begin optimizing. It is only close if you don't do any optimizations and you use the default standard shaders of Unity in both pipelines. Which is something nobody who wants performance would do because everybody knows that the standard Unity shaders in the built-in are horrible in mobile.

 

URP Simple Lit is more complex than Built-in Mobile Diffuse:

• Forward PBR Lighting (Specular Highlights, Emission, NormalMap, ...)
• Depth Support (useful for post-processing)
• Depth Normal Support (useful for post-processing)
• Baked Lighting
• ...
• (Future) Motion Vector (for TAA probably)

If you need those techs for better visual quality, Mobile Diffuse may not satisfy you.

Currently the best way is to write a custom shader that is similar to Mobile Diffuse, or submit ideas on URP Roadmap (Not suggested because you may need to wait for a long time).

 

Exactly. That's what I was asking. If there was a similar shader available in the asset store or done already. Or how hard it would be to make a Mobile Diffuse in URP so that I can avoid all those costly calculations.

 

First Note: I have made 30 mobile games so far and I know everything about lighting, shaders, graphics and optimization.
Therefore, I confirm that the settings are 100% the same between standard and Universal Pipelines
Note 2: 4K resolution on the Redmi 9A without shadows (only directional light)
Note 3: No reflection probes or sky reflections
Note 4: Project has been made in standard pipeline and then converted to the URP with exactly same settings in depth
Note 5: Color grading, Vignette and HDR ACES tonemapping has been used
Note 6: Unity 2021.2.16 and Linear color space
Note 7: You must disable additional light in URP Asset or use Vertex lit as additional lighting. Additional pixel light will reduce your fps to the half

As i said before, i have tested urp and standard shaders before... URP baked lit is the fasted shader in the world... Simple lit can be faster than Diffuse shader... I will compare them soon

Download Android APKs

Download Projects for Unity 2021







URP Asset Settings

 

Can you please reduce the render scale (to 0.7 for example) on URP and use FSR as filter and post the results
I'm currently in the process of upgrading from 21.1 to 21.2 i want to see if it's worth it

 

Unfortunately no. I don't have time
You can download the project and try it yourself

 

This is the most optimized terrain shader with only 4 splats and UV calculation on the vertex program (built-in pipeline)

Code (CSharp):

1. // Originally written by ALIyerEdon Summer-Fall 2016
2. Shader "Nature/Terrain/Diffuse (Optimized 4 Splat)"
3. {
4.     Properties
5.     {
6.         // Shader properties that you can see and change it on inspector
7.         _Control ("Control (RGBA)", 2D) = "red" {}
8.         _Splat0 ("Ch (R)", 2D) = "white" {}
9.         _Splat1 ("Ch (G)", 2D) = "white" {}
10.         _Splat2 ("Ch (B)", 2D) = "white" {}
11.         _Splat3 ("Ch (A)", 2D) = "white" {}
12.  
13.         _UV1("Splat1 & Splat3 Tile",Float) =   43
14.  
15.         _UV2("Splat2 & Splat4 Tile",Float) =   43
16.     }
17.    
18.     SubShader // Main shader body
19.     {
20.         Tags
21.         {
22.             "SplatCount" = "4"  // Need 4 splat for terrain
23.             "Queue" = "Geometry-100"
24.             "RenderType" = "Opaque" // This is Opaque and is not Transparent shader
25.         }
26.    
27.  
28.     LOD 200
29.     CGPROGRAM
30.  
31.     // Use Lambert lighting
32.     #pragma surface surf Lambert vertex:vert
33.  
34.     // Can run on GLES2+ - Works on all platforms supported by Unity
35.     #pragma target 2.0
36.  
37.     struct Input
38.     {
39.         float2 uv_Control : TEXCOORD0;
40.         float2 customUV1;
41.         float2 customUV2;
42.     };
43.  
44.     // Properties
45.     sampler2D _Control;
46.     sampler2D _Splat0,_Splat1,_Splat2,_Splat3;
47.     half _UV1;
48.     half _UV2;
49.  
50.     // Vertex shader
51.     void vert (inout appdata_full v, out Input o)
52.     {
53.         UNITY_INITIALIZE_OUTPUT(Input,o);
54.  
55.         // Custom UV is unreal engine way for solving mali400 pixelled tiling problem
56.         // And use this for more performance compare to pixel shader
57.         o.customUV1 = v.texcoord.xy *_UV1;o.customUV2 = v.texcoord.xy *_UV2;
58.     }
59.  
60.     // Pixel shader
61.     void surf (Input IN, inout SurfaceOutput o)
62.     {
63.         float4 splat_control = tex2D (_Control, IN.uv_Control);
64.         float3 col;
65.         col  = splat_control.r * tex2D (_Splat0, IN.customUV1).rgb;
66.         col += splat_control.g * tex2D (_Splat1, IN.customUV2).rgb;
67.         col += splat_control.b * tex2D (_Splat2, IN.customUV1).rgb;
68.         col += splat_control.a * tex2D (_Splat3, IN.customUV2).rgb;
69.         o.Albedo = col;
70.     }
71.     ENDCG
72.     }
73.  
74.     Fallback "Nature/Terrain/Diffuse"
75. }
76.  

Reference

 

That project is a really bad test to compare URP. You have things there that should not be used in mobile at all, most processing time goes to something that is not shader related. I loaded in my old device and it was running at 7 fps.

After a few adjustments on the same device, now with real time lighting, antialiasing and shadows enabled, it's running at max 30 fps on the same android device, and I didn't even change the shaders (which can be x10 faster). If you want to test URP vs built-in you can't use that project really. You need to check the profiler to realize how slow URP is vs built in mobile shaders (in order of x4 slower in this device btw if i switch to URP). In URP I made the same changes and it keeps running at 8 fps unless I remove the shaders and install my own.

Picture, it was running at 7 fps with your settings. After I made some basic changes...

 

Because the test project is the same on both pipelines, and only the terrain shader is different, the above test is 100% correct and performance related to the shader.
As you can see in the images above, performance changes as you change the terrain shaders
I can change settings and get 120fps... But on the all pipelines you needs to do same thing. I have used post processing to see the final performance result for a real completed game

I hope you think wiser
I no longer see the need to continue this discussion
Choose any pipeline you like

Goodbye

 

Again, if you place the wrong settings so that Built-in runs slow and then compare it to URP. It doesn´t make sense. You just said you can optimize that to run at 120 fps on that mobile device. I doubt it, prove it. Now achieve the same in URP, good luck with that. The whole conversation here is that you say that URP is as fast as built-in and i think it´s been proven many times that is not true. it´s only as fast if you only use the default unity shaders (which are horribly slow). Once you begin optimizing, URP never beats built-in in performance or memory requirements except in very very very few specific cases. All my tests for URP are at least 4 times slower than built-in mobile shaders.

 

As i said before, i have made 30 mobile games for mali 400 target from 7 years ago... I know everything about built-in and urp settings... The settings are 100% the same in the test project in depth... No one can do it better than me

 

I also converted Auto Exposure tonemmaper for mobile devices in built-in pipeline without performance lost. This effect is not available for URP for now

Downlead for free

 

Your settings are wrong, tons of people can do it better than you. I just did. And even with all my experience, I know many people can do better than me. So get out of that high horse and run the profiler to compare URP vs Built-in mobile shaders in the gpu. This is not a "who knows more" contest. You just keep posting links to your store assets to sell yourself. I was Unity alpha tester before you were even into Unity. Just check the "joined" date in the forum. This interaction adds no value to the thread: URP vs Built in mobile shaders performance. Your project is basically stuck at rendering Unity terrain mesh most of the time, not the shader. Unity terrain in mobile is ultra slow in the cpu, nothing to do with the shader or URP. If you run a profiler you know this immediately.

You can download my game which has terrain, water, over 40k trees, real-time lighting, shadows, changing weather, fog, multiplayer and way more things and it runs faster than the project you provided which only has a terrain. Obviously, your setup is wrong but with your response, I doubt anyone will be willing to help you. You can download my “apk” for free here https://play.google.com/store/apps/details?id=com.echoboom.dogfightelite&hl=en_US&gl=PA

Anyway, just run a Gpu profiler and you can easily see that URP is way slower than standard pipeline mobile diffuse. Case close for me.

 

Instead of saying this in vain, tell me where the settings are not the same?

If you showed me the settings that are not the same, I will continue the discussion with you

Spoiler

Also, my income from the Asset Store last month was $ 700. I got $ 500 for half an hour of lighting. And with a simple mobile game, I will earn several thousand dollars from advertisements. Sales at the UE marketplace is several times more than unity's asset store

Also my all links was free assets

Also i have used unity from the first release of the windows version in the first week
I was dx9 game engine programmer and seen unity's windows release news on the devmaster.net website. Unreal Engine 3 was more than 700.000 usd

 

As someone with high hopes for URP I'm disappointed after over a year I'm going back to Built-in and everyone who is targeting mobile platforms should avoid it for now

The result I'm getting is unbelievable my game is visually ambitious and I didn't test on actual devices for months but come on guys not even 30FPS at 540p ???

Unity failed with URP we will see how they gonna optimize their game

~450 draw calls
~950k Tris
Mix of Lit and Simple Lit
And after only Simple Lit
Standard shader for Built-in (normal map + maskmap + occlusion map)

Reflection and Specular Highlight are both ON for every material

Fully baked lighting (with shadowmask but all shadow caster disabled)

PP OFF
MSAA OFF
HDR ON

2198x1080(i know I shouldn't but I had to stress test it) : ~9FPS vs ~30FPS(built-in)
GPU usage : ~97%

1648x810 : ~15FPS vs ~30FPS(vsync on it's should be more with if i target 60)
GPU usage : ~74%

1099x540 : ~20FPS vs ~30FPS(vsync on it's should be more with if i target 60)
GPU usage : ~41%

Unity 2021.2.18
URP 12

Note : GPU usage is for Built-in on URP is always around 80% and for 1080p test the CPU was around 85% too
On built-in the CPU is around 30-40%

And with deep profiling on you can clearly see their C# thing Is way too slow

Device Used
Xiaomi mi 8 lite
Snapdragon 660 Adreno 512

 

My tests when porting www.dogfightelite.com to URP, using a Kindle Fire 7. Which is a very old crappy device.

For the built-in system I used mobile/diffuse for almost every shader with Lux Water shader for the water.

For URP I used mostly URP Simple Lit, with only a custom shader for the water (I tried with Lux Essentials and Stylized Water 2 with the same FPS).

When I lower the quality, the water is completely removed so as to compare apples to apples.

The game also has a few thousand trees created with Unity Tree Creator. A 4km x 4km terrain. No grass.

Results:


1) Full resolution and highest game settings (real-time lighting and shadows, water).
- In built-in: 30 fps. The maximum. It will fall under 30 fps only when many players are on screen.
- URP: It won't load. It runs out of memory. The profiler shows that 2/3 of the RAM is going into the URP Shaders. Over 350mb of ram.

2) Lowest quality settings, full resolution. (I disable real-time lighting, no shadows and I remove the water completely).
Builtin: 30 fps. The maximum. It never goes under 30 fps.
URP: It loads. It runs at 9 fps. The ram requirement is almost double the built-in requirement, this time the shaders are taking about 200mb of RAM.

3) Lowest quality settings, half resolution.
Builtin: Same as step 2. It never goes under 30 fps.
URP: It runs at 14 fps. Same ram as step 2.

Some might argue that a Kindle Fire 7 is a horrible device. It is by today's standards. But it runs my game perfectly fine at full speed and with real time lighting when using Built-in. And this game used to run on an iphone 4 when Unity4 was out.


Problems I encountered while porting and that I did not expect:
1) URP shaders take a HUGE amount of RAM. You have to manually do some serious shader stripping and even after all the "optimized" settings, the RAM usage is off the charts.

2) URP Terrain shader loads about 4 other shaders in memory. Including URP Lit, not even Simple Lit. It totals about 150mb in ram only for the terrain shaders. My 4km x 4km terrain with 4 textures takes about 30mb of RAM. The shader alone takes 5 times more!
I tried using Microsplat and Lux Essentials terrain shader. Their URP version seems to run at the same fps and consume the same RAM because internally they are loading the URP Terrain shader too. So no benefits in that aspect.

3) URP shaders perform similar in speed to the Standard shaders in built-in. But they are ultra slow compared to mobile/diffuse. In built-in, if we wanted performance, we never used the standard shaders, we switched to mobile versions. We don't even have that option in URP so we are stuck with slow PBR shaders.

4) Tree creator is not supported in URP. One of the most wonderful things about Unity and I never complained about, is that it was able to render thousands of those trees even in an iPhone 4. URP forces us to use Speedtree, which is notoriously slow in mobile. (we always made fun of the name).

5) I encountered tons of issues rendering sky and weather in a performant way. The shader is either slow or takes too much ram. The available packages in URP are not really optimized for mobile. I had to spend lots of time writing my own shaders and optimizing everything I purchased in the store. I was able to x3 the performance of Unistorm and other packages from their default settings, but they were all still rendering slower than built-in counterparts.

6) Terrain rendering in URP is even slower than Built-in. Which was already pretty bad. Also URP Terrain in mobile looks horrible due to long standing bugs.

7) Lens flares and sun flares. They sometimes work, they sometimes don't.

8) Shadows. I had to spend a crazy amount of time to get real-time shadows for mobile in URP to look decent compared to built-in and at worse performance.

9) Water. It always amazes me that we have a billion water packages in the store. The community ocean package (which is free) was rendering at highest quality in an iphone 5 and looked fantastic. Unfortunately, nobody maintained that package and you have to spend money in URP to achieve 1/4 the same quality at half the performance and triple the memory requirements in 2022 URP vs 2015 Built-in. I just don't get it.

10) Vulkan in URP. In almost every test I've done on my Android devices, Vulkan in URP performs worse than Opengles 3.0, to the point I gave up the fight and I just don't use Vulkan and force it to build for Opengles 3.0. This was especially bad in my Oculus Quest 2 tests which is supposed to have tons of benefits in Vulkan. I experienced no benefits whatsoever.

11) I had to spend a ridiculous amount of money to migrate some assets to their URP version. Just to find out that the non-urp version was performing much better. But you won't get a refund... so it's a huge money pit to migrate just to "check".

Conclusion: As of today, migrating your project from built-in to URP seems to offer no benefit whatsoever. I cannot think of anything you can do in URP and you cannot achieve in built-in, faster, and with fewer memory requirements when developing for mobile at this moment. Meanwhile, you can see all the issues and troubles I found while doing the migration.

I also did all the tests in Unity 2021.2.19f, Unity 2022.1.15b and Unity 2022.2.9a and I found not much difference or improvements between the versions. I've also submitted several bug reports with the things I was encountering, just so you know I don't go complaining and don't do anything about it. I always report what I find and although I'm loud about it, I help to fix things when Unity listens.

URP has still a long way to go in performance and RAM optimization as of April 2022 just to catch up with what we already had in built-in.

 

I'd like to hear from Unity Staff on this thread. We are starting a project now, and assumed URP should be the way to go. But our first stress test was 2000 non-instanced animated models on a plane (2200 tris each, low poly), and in Built-in, it rendered easily at 40 FPS, on a new fast PC.

Then I switched over to URP and used Simple-Lit shaders for this model -- and the FPS is now 18 FPS! (less than half!)

I dinked around with settings comparing the two side-by-side, and couldn't find a way to make URP run faster. We have nothing complex going on here -- just a single standard directional light, free-fly camera, a plane, and 2000 models dancing. No physics. No game logic. Just executing 2000 animations via the built-in Animator, looping on the Dance animation.

NOTE: If I disable the Animator -- for both scenarios, the FPS remains unchanged.

And Built-in kicks URP's butt. I didn't compare RAM size yet.

===
As for our game will be Terrain centric God-View (from above, will never be ground level), with only a couple hundred low-poly animated models... So mostly what matters for our performance will come down to rendering terrain, vegetation, and static model content (houses, fences, roads). It's going to target Desktop (Windows/Mac) only.

We don't need next-gen rendering capability -- We think built-in will work for us just fine. Are there any downsides to choosing Built-in for a project starting now. And has anyone figured out how to overcome these major performance and Memory issues caused by URP?

I'd like to hear from Unity Staff on the ETA for fixing the URP issues that exist. At this point, I haven't even seen them acknowledge the major problems (performance and memory).

 

Does Unity officially acknowledge their screwup with URP? (I won't say HDRP, because you can consider HDRP a move towards supporting Movie-making - and so performance is less of an issue, for FPS, although it does hinder the making of AAA-like games with advanced rendering).

I used the profiler on both Built-in vs. URP, and can't see anything specific to explain why URP needs to run at only 40% the frame rate, for a simple example.

Our game doesn't need anything that Unity Built-in didn't already support, from what I can tell. So our tentative plan is to simply go with the Built-in pipeline, and then after another year will check back on URP.

It would be nice for Unity to officially recognize the severe performance issues that happen with URP out-of-box (slower FPS and more RAM), and to indicate if/when they are going to address this issue, to at least make URP work "more comparable to Built-in" out-of-box.

Their silence on this matter is what concerns me most. Silence usually indicates "they have no answer" and so are trying to misdirect your attention elsewhere, hoping to keep your loyalty/business.

 

If you look around on the URP forums there's plenty of dev replies addressing your concerns. Perhaps they just are too busy for speculation?

To be honest, there's no value or constructive reason to keep this thread open.