This site below runs tests comparing `translate()`, `translate3d()`, and a couple other properties. According to it, `translate3d()` is faster in most browsers.

http://jsperf.com/translate3d-vs-xy

The use of translate3d pushes CSS animations into hardware acceleration. Even if you&#39;re looking to do a basic 2d translation, use translate3d for more power! So &#39;T3d&#39; is just better because it tells the CSS animations to push the animations in 3d power!
That&#39;s why it is faster.
(The answer of Cameron Little is the proof)


As Cameron suggested `translate3d` should be faster in a lot of browsers, mostly those that use GFX hardware acceleration to speed up rendering. Especially on WebKit `translate3d` was the preferred way of forcing hardware acceleration on page items. 

Though in my experience sometimes there is one drawback to using 3d transforms - in certain browser versions/OS combinations (macOS + Safari I&#39;m looking at you) hardware accelerated rendering can slightly alter font smoothing as well as interpolation, thus causing minor flicker or blur. Those situations can mostly be worked around but should be kept in mind. 

I am having issues with sonar picking up the jacoco analysis report. Jenkins however is able to pick up the report and display the results.
My project is a maven build, built by Jenkins. The jacoco report is generated by maven (configured in the pom). Sonar is executed by using the Jenkins plugin.

This is what I see on SonarQube:

![SonarQube Screen Capture][1]

This is the report i can see of the project in jenkins.

![Jacoco report in Jenkins][2]

The maven plugin config:

&lt;!-- language: xml --&gt;

    &lt;plugin&gt;
        &lt;groupId&gt;org.jacoco&lt;/groupId&gt;
        &lt;artifactId&gt;jacoco-maven-plugin&lt;/artifactId&gt;
        &lt;version&gt;0.6.4.201312101107&lt;/version&gt;
        &lt;executions&gt;
          &lt;execution&gt;
            &lt;id&gt;default-prepare-agent&lt;/id&gt;
            &lt;goals&gt;
                &lt;goal&gt;prepare-agent&lt;/goal&gt;
            &lt;/goals&gt;
          &lt;/execution&gt;
          &lt;execution&gt;
            &lt;id&gt;default-report&lt;/id&gt;
            &lt;phase&gt;prepare-package&lt;/phase&gt;
            &lt;goals&gt;
                &lt;goal&gt;report&lt;/goal&gt;
            &lt;/goals&gt;
          &lt;/execution&gt;
          &lt;execution&gt;
              &lt;id&gt;default-check&lt;/id&gt;
              &lt;goals&gt;
                  &lt;goal&gt;check&lt;/goal&gt;
              &lt;/goals&gt;
          &lt;/execution&gt;
        &lt;/executions&gt;
    &lt;/plugin&gt;




Jenkins Sonar Plugin config
![enter image description here][3]


  [1]: http://i.stack.imgur.com/r8aYd.png
  [2]: http://i.stack.imgur.com/XRGda.png
  [3]: http://i.stack.imgur.com/C3HuP.png

SonarQube not picking up Unit Test Coverage

I&#39;m iterating over a list in **Handlebars** using the built-in `each` helper.
Within the each block, I&#39;m referencing the **current loop index** `{{@index}}` to print the consecutive number of an item:

    &lt;script id=&quot;list-item-template&quot; type=&quot;text/x-handlebars-template&quot;&gt;
    	{{#each items}}
    	&lt;li class=&quot;topcoat-list__item&quot;&gt;
        	&lt;a href=&quot;#{{@index}}&quot;&gt;Item number {{@index}}&lt;/a&gt;
        &lt;/li&gt;
        {{/each}}
    &lt;/script&gt;

This gives the following output:

 - Item number 0
 - Item number 1
 - Item number 2
 - ....

The problem is that I want to display an offsetted index which starts with 1 instead of 0.

I tried to perform calculations on the index like `{{@index+1}}`, but this just leads to an 
&gt; Uncaught Error: Parse error

Adding offset to {{@index}} when looping through items in Handlebars

We now all know, particularly from [that nice article](http://www.paulirish.com/2012/why-moving-elements-with-translate-is-better-than-posabs-topleft/), that we should prefer css-transforms to animate position.

But we got the choice between `translate()` and `translate3d()`...

Which one is *generally* faster?

translate3d vs translate performance

We now all know, particularly from <a href="http://www.paulirish.com/2012/why-moving-elements-with-translate-is-better-than-posabs-topleft/" target="_blank" rel="noopener noreferrer">that nice article</a>, that we should prefer css-transforms to animate position.
But we got the choice between <code>translate()</code> and <code>translate3d()</code>...
Which one is generally faster?

Does anybody know what is the meaning of _stalled-cycles-frontend_ and _stalled-cycles-backend_ in perf stat result ? I searched on the internet but did not find the answer. Thanks

    $ sudo perf stat ls                     

    Performance counter stats for &#39;ls&#39;:

          0.602144 task-clock                #    0.762 CPUs utilized          
                 0 context-switches          #    0.000 K/sec                  
                 0 CPU-migrations            #    0.000 K/sec                  
               236 page-faults               #    0.392 M/sec                  
            768956 cycles                    #    1.277 GHz                    
            962999 stalled-cycles-frontend   #  125.23% frontend cycles idle   
            634360 stalled-cycles-backend    #   82.50% backend  cycles idle
            890060 instructions              #    1.16  insns per cycle        
                                             #    1.08  stalled cycles per insn
            179378 branches                  #  297.899 M/sec                  
              9362 branch-misses             #    5.22% of all branches         [48.33%]

       0.000790562 seconds time elapsed


What are stalled-cycles-frontend and stalled-cycles-backend in &#39;perf stat&#39; result?

How much is the overhead of smart pointers compared to normal pointers in C++11? In other words, is my code going to be slower if I use smart pointers, and if so, how much slower?

Specifically, I&#39;m asking about the C++11 `std::shared_ptr` and `std::unique_ptr`.

*Obviously, the stuff pushed down the stack is going to be larger (at least I think so), because a smart pointer also needs to store its internal state (reference count, etc), the question really is, how much is this going to affect my performance, if at all?*

For example, I return a smart pointer from a function instead of a normal pointer:

    std::shared_ptr&lt;const Value&gt; getValue();
    // versus
    const Value *getValue();

Or, for example, when one of my functions accept a smart pointer as parameter instead of a normal pointer:

    void setValue(std::shared_ptr&lt;const Value&gt; val);
    // versus
    void setValue(const Value *val);

How much is the overhead of smart pointers compared to normal pointers in C++?

This is not a terribly uncommon question, but I still couldn&#39;t seem to find an answer that really explained the choice.

I have a very large list of strings (ASCII representations of [SHA-256][1] hashes, to be exact), and I need to query for the presence of a string within that list.

There will be what is likely in excess of 100 million entries in this list, and I will need to repeatably query for the presence of an entry many times.

Given the size, I doubt I can stuff it all into a `HashSet&lt;string&gt;`. What would be an appropriate retrieval system to maximize performance?

I CAN pre-sort the list, I CAN put it into a SQL table, I CAN put it into a text file, but I&#39;m not sure what really makes the most sense given my application.

Is there a clear winner in terms of performance among these, or other methods of retrieval?

  [1]: http://en.wikipedia.org/wiki/SHA-2


What&#39;s an appropriate search/retrieval method for a VERY long list of strings?

I came across this [old question](https://stackoverflow.com/questions/6146182/how-to-optimize-for-comprehensions-and-loops-in-scala) and did the following experiment with scala 2.10.3.

I rewrote the Scala version to use explicit tail recursion:

    import scala.annotation.tailrec
    
    object ScalaMain {
      private val t = 20
    
      private def run() {
        var i = 10
        while(!isEvenlyDivisible(2, i, t))
          i += 2
        println(i)
      }
    
      @tailrec private def isEvenlyDivisible(i: Int, a: Int, b: Int): Boolean = {
        if (i &gt; b) true
        else (a % i == 0) &amp;&amp; isEvenlyDivisible(i+1, a, b)
      }
    
      def main(args: Array[String]) {
        val t1 = System.currentTimeMillis()
        var i = 0
        while (i &lt; 20) {
          run()
          i += 1
        }
        val t2 = System.currentTimeMillis()
        println(&quot;time: &quot; + (t2 - t1))
      }
    }

and compared it to the following Java version. I consciously made the functions non-static for a fair comparison with Scala:

    public class JavaMain {
        private final int t = 20;
    
        private void run() {
    	    int i = 10;
    	    while (!isEvenlyDivisible(2, i, t))
                i += 2;
    	    System.out.println(i);
        }
    
        private boolean isEvenlyDivisible(int i, int a, int b) {
    	    if (i &gt; b) return true;
            else return (a % i == 0) &amp;&amp; isEvenlyDivisible(i+1, a, b);
        }
    
        public static void main(String[] args) {
            JavaMain o = new JavaMain();
    	    long t1 = System.currentTimeMillis();
            for (int i = 0; i &lt; 20; ++i)
              o.run();
    	    long t2 = System.currentTimeMillis();
    	    System.out.println(&quot;time: &quot; + (t2 - t1));
        }
    }

Here are the results on my computer:

    &gt; java JavaMain
    ....
    time: 9651
    &gt; scala ScalaMain
    ....
    time: 20592

This is scala 2.10.3 on (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_51).

My question is what is the hidden cost with the scala version?

Many thanks.


Hidden performance cost in Scala?

I&#39;m new to Java 8. I still don&#39;t know the API in depth, but I&#39;ve made a small informal benchmark to compare the performance of the new Streams API vs the good old Collections. 

The test consists in filtering a list of `Integer`, and for each even number, calculate the square root and storing it in a result `List` of `Double`.

Here is the code:

		public static void main(String[] args) {
			//Calculating square root of even numbers from 1 to N		
			int min = 1;
			int max = 1000000;
			
			List&lt;Integer&gt; sourceList = new ArrayList&lt;&gt;();
			for (int i = min; i &lt; max; i++) {
				sourceList.add(i);
			}

			List&lt;Double&gt; result = new LinkedList&lt;&gt;();
			
			
			//Collections approach
			long t0 = System.nanoTime();
			long elapsed = 0;
			for (Integer i : sourceList) {
				if(i % 2 == 0){
					result.add(Math.sqrt(i));
				}
			}
			elapsed = System.nanoTime() - t0;		
			System.out.printf(&quot;Collections: Elapsed time:\t %d ns \t(%f seconds)%n&quot;, elapsed, elapsed / Math.pow(10, 9));
			
			
			//Stream approach
			Stream&lt;Integer&gt; stream = sourceList.stream();		
			t0 = System.nanoTime();
			result = stream.filter(i -&gt; i%2 == 0).map(i -&gt; Math.sqrt(i)).collect(Collectors.toList());
			elapsed = System.nanoTime() - t0;		
			System.out.printf(&quot;Streams: Elapsed time:\t\t %d ns \t(%f seconds)%n&quot;, elapsed, elapsed / Math.pow(10, 9));
			
			
			//Parallel stream approach
			stream = sourceList.stream().parallel();		
			t0 = System.nanoTime();
			result = stream.filter(i -&gt; i%2 == 0).map(i -&gt; Math.sqrt(i)).collect(Collectors.toList());
			elapsed = System.nanoTime() - t0;		
			System.out.printf(&quot;Parallel streams: Elapsed time:\t %d ns \t(%f seconds)%n&quot;, elapsed, elapsed / Math.pow(10, 9));		
		}.

And here are the results for a dual core machine:

		Collections: Elapsed time:	      94338247 ns 	(0,094338 seconds)
		Streams: Elapsed time:		     201112924 ns 	(0,201113 seconds)
		Parallel streams: Elapsed time:	 357243629 ns 	(0,357244 seconds)

For this particular test, streams are about twice as slow as collections, and parallelism doesn&#39;t help (or either I&#39;m using it the wrong way?).

Questions:

 - Is this test fair? Have I made any mistake? 
 - Are streams slower than collections? Has anyone made a good formal benchmark on this?
 - Which approach should I strive for?


----------

**Updated results.**

I ran the test 1k times after JVM warmup (1k iterations) as advised by @pveentjer:

		Collections: Average time:	 	206884437,000000 ns 	(0,206884 seconds)
		Streams: Average time:	 	 	 98366725,000000 ns 	(0,098367 seconds)
		Parallel streams: Average time:	167703705,000000 ns 	(0,167704 seconds)

In this case streams are more performant. I wonder what would be observed in an app where the filtering function is only called once or twice during runtime.

Java 8: performance of Streams vs Collections

I want to find out how to make a **spinning or rotating image** when it is hovered. I would like to know how to emulate that functionality with *CSS* on the following code :

&lt;!-- begin snippet: js hide: false --&gt;

&lt;!-- language: lang-css --&gt;

    img {
      border-radius: 50%;
    }

&lt;!-- language: lang-html --&gt;

    &lt;img src=&quot;http://i.imgur.com/3DWAbmN.jpg&quot; /&gt;

&lt;!-- end snippet --&gt;



Spin or rotate an image on hover

I am experimenting with css filters.

And I would like use the blur and grayscale at the same time, but I can&#39;t seem to use both simultaneously on the same image?

See fiddle here...

http://jsfiddle.net/joshmoto/fw0m9fzu/1/

    .blur {
        filter: blur(5px);
    	-webkit-filter: blur(5px);
    	-moz-filter: blur(5px);
    	-o-filter: blur(5px);
    	-ms-filter: blur(5px);
    }
    
    .grayscale {
        filter: grayscale(1);
    	-webkit-filter: grayscale(1);
    	-moz-filter: grayscale(1);
    	-o-filter: grayscale(1);
    	-ms-filter: grayscale(1);
    }

&lt;br/&gt;

    .blur-grayscale {
        filter: blur(5px) grayscale(1);
    	-webkit-filter: blur(5px) grayscale(1);
    	-moz-filter: blur(5px) grayscale(1);
    	-o-filter: blur(5px) grayscale(1);
    	-ms-filter: blur(5px) grayscale(1);
    }


use multiple css filters at the same time?

I&#39;m trying to get a **transition hover effect on border** that the border expands on hover. 
  

&lt;!-- begin snippet: js hide: false --&gt;

&lt;!-- language: lang-css --&gt;

    h1 {
      color: #666;
    }

    h1:after {
      position: absolute;
      left: 10px;
      content: &#39;&#39;;
      height: 40px;
      width: 275px;
      border-bottom: solid 3px #019fb6;
      transition: left 250ms ease-in-out, right 250ms ease-in-out;
      opacity: 0;
    }

    h1:hover:after {
      opacity: 1;
    }

&lt;!-- language: lang-html --&gt;

    &lt;h1&gt;CSS IS AWESOME&lt;/h1&gt;

&lt;!-- end snippet --&gt;

I&#39;ve tried this on [Jsfiddle][1]


  [1]: http://jsfiddle.net/mfn5nefb/

Hover effect : expand bottom border

Is it possible to apply a CC translate X and Y on the same element? 

If I try this the translateX is overridden by the translateY: 

    .something { 
            transform: translateX(-50%);
            transform: translateY(-50%);
    }

translateX and translateY on same element?

**tl;dr:** *I would like to create an actual 3d sphere with CSS - not just an illusion*

Note: some of the snippet examples are not responsive. Please use full screen. 


----------


With pure CSS you can **create and animate**  a 3d cube like so:



&lt;!-- begin snippet: js hide: true console: true babel: false --&gt;

&lt;!-- language: lang-css --&gt;

    #cube-wrapper {
      position: absolute;
      left: 50%;
      top: 50%;
      perspective: 1500px;
    }

    .cube {
      position: relative;
      transform-style: preserve-3d;
      animation-name: rotate;
      animation-duration: 30s;
      animation-timing-function: linear;
      animation-iteration-count: infinite;
    }

    @keyframes rotate {
      0% {
        transform: rotate3d(0, 0, 0, 0);
      }
      100% {
        transform: rotate3d(0, 1, 0, 360deg);
        ;
      }
    }

    .face {
      position: absolute;
      width: 200px;
      height: 200px;
      border: solid green 3px;
    }

    #front_face {
      transform: translateX(-100px) translateY(-100px) translateZ(100px);
      background: rgba(255, 0, 0, 0.5);
    }

    #back_face {
      transform: translateX(-100px) translateY(-100px) translateZ(-100px);
      background: rgba(255, 0, 255, 0.5);
    }

    #right_face {
      transform: translateY(-100px) rotateY(90deg);
      background: rgba(255, 255, 0, 0.5);
    }

    #left_face {
      transform: translateY(-100px) translateX(-200px) rotateY(90deg);
      background: rgba(0, 255, 0, 0.5);
    }

    #top_face {
      transform: translateX(-100px) translateY(-200px) rotateX(90deg);
      background: rgba(0, 255, 255, 0.5);
    }

    #bottom_face {
      transform: translateX(-100px) rotateX(90deg);
      background: rgba(255, 255, 255, 0.5);
    }

    .cube {
      transform: rotateX(90deg) rotateY(90deg);
    }

&lt;!-- language: lang-html --&gt;

    &lt;div id=&quot;cube-wrapper&quot;&gt;
      &lt;div class=&quot;cube&quot;&gt;
        &lt;div id=&quot;front_face&quot; class=&quot;face&quot;&gt;&lt;/div&gt;
        &lt;div id=&quot;right_face&quot; class=&quot;face&quot;&gt;&lt;/div&gt;
        &lt;div id=&quot;back_face&quot; class=&quot;face&quot;&gt;&lt;/div&gt;
        &lt;div id=&quot;left_face&quot; class=&quot;face&quot;&gt;&lt;/div&gt;
        &lt;div id=&quot;top_face&quot; class=&quot;face&quot;&gt;&lt;/div&gt;
        &lt;div id=&quot;bottom_face&quot; class=&quot;face&quot;&gt;&lt;/div&gt;
      &lt;/div&gt;
    &lt;/div&gt;

&lt;!-- end snippet --&gt;

**I want to create and animate a 3d sphere in the same manner.**

So... the first idea I get is to use `border-radius` and...well... it doesn&#39;t work. 




&lt;!-- begin snippet: js hide: true console: true babel: false --&gt;

&lt;!-- language: lang-css --&gt;

    #cube-wrapper {
      position: absolute;
      left: 50%;
      top: 50%;
      perspective: 1500px;
    }

    .cube {
      position: relative;
      transform-style: preserve-3d;
      animation-name: rotate;
      animation-duration: 30s;
      animation-timing-function: linear;
      animation-iteration-count: infinite;
    }

    @keyframes rotate {
      0% {
        transform: rotate3d(0, 0, 0, 0);
      }
      100% {
        transform: rotate3d(0, 1, 0, 360deg);
       
        ;
      }
    }


    .face {
      position: absolute;
      width: 200px;
      height: 200px;
      border: solid green 3px;
      border-radius: 100vw
    }


     

    #front_face {
      transform: translateX(-100px) translateY(-100px) translateZ(100px);
      background: rgba(255, 0, 0, 0.5);
    }

    #back_face {
      transform: translateX(-100px) translateY(-100px) translateZ(-100px);
      background: rgba(255, 0, 255, 0.5);
    }

    #right_face {
      transform: translateY(-100px) rotateY(90deg);
      background: rgba(255, 255, 0, 0.5);
    }

    #left_face {
      transform: translateY(-100px) translateX(-200px) rotateY(90deg);
      background: rgba(0, 255, 0, 0.5);
    }

    #top_face {
      transform: translateX(-100px) translateY(-200px) rotateX(90deg);
      background: rgba(0, 255, 255, 0.5);
    }

    #bottom_face {
      transform: translateX(-100px) rotateX(90deg);
      background: rgba(255, 255, 255, 0.5);
    }

    .cube {
      transform: rotateX(90deg) rotateY(90deg);
    }

&lt;!-- language: lang-html --&gt;

    &lt;div id=&quot;cube-wrapper&quot;&gt;
      &lt;div class=&quot;cube&quot;&gt;
        &lt;div id=&quot;front_face&quot; class=&quot;face&quot;&gt;&lt;/div&gt;
        &lt;div id=&quot;right_face&quot; class=&quot;face&quot;&gt;&lt;/div&gt;
        &lt;div id=&quot;back_face&quot; class=&quot;face&quot;&gt;&lt;/div&gt;
        &lt;div id=&quot;left_face&quot; class=&quot;face&quot;&gt;&lt;/div&gt;
        &lt;div id=&quot;top_face&quot; class=&quot;face&quot;&gt;&lt;/div&gt;
        &lt;div id=&quot;bottom_face&quot; class=&quot;face&quot;&gt;&lt;/div&gt;
      &lt;/div&gt;
    &lt;/div&gt;

&lt;!-- end snippet --&gt;


So, I reconsidered my approach and looked for a different method. 

I looked at:

 - https://stackoverflow.com/questions/29300573/implementing-pure-css-sphere-into-website-how-do-i-do-it
 - https://stackoverflow.com/questions/30891893/how-to-create-a-sphere-in-css
 - [Display an image wrapped around a sphere with CSS/Javascript
   ](https://stackoverflow.com/a/24561907/8157693)
 - [cssanimation.rocks - CSS spheres](https://cssanimation.rocks/spheres/)
 - [MDN -
   Circle](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/circle)
 

 

Then I tried again...the best I got were overly *complicated* 3d object **illusions**. 

Like this:

&lt;!-- begin snippet: js hide: true console: true babel: false --&gt;

&lt;!-- language: lang-css --&gt;

    body {
      overflow: hidden;
      background: #333;
    }

    .wrapper {
      margin: 1em;
      animation-duration: 20s;
    }

    .planet,
    .planet:before,
    .planet:after {
      height: 300px;
      width: 300px;
      border-radius: 100vw;
      will-change: transform;
      margin: 0 auto;
    }

    .planet {
      box-shadow: inset 0px 0px 10px 10px rgba(0, 0, 0, 0.4);
      position: relative;
    }

    .wrapper,
    .planet,
    .planet:before {
      animation-name: myrotate;
      animation-duration: 20s;
    }

    .wrapper,
    .planet,
    .planet:before,
    .planet:after {
      animation-timing-function: linear;
      animation-iteration-count: infinite;
    }

    .planet:before,
    .planet:after {
      content: &#39;&#39;;
      position: absolute;
      top: 0;
      left: 0;
    }

    .planet:before {
      box-shadow: inset 20px 20px 100px 00px rgba(0, 0, 0, .5), 0px 0px 5px 3px rgba(0, 0, 0, .1);
    }

    .planet:after {
      filter: saturate(2.5);
      background: linear-gradient(rgba(0, 0, 0, 1), transparent), url(&quot;https://i.stack.imgur.com/eDYPN.jpg&quot;);
      opacity: 0.3;
      box-shadow: inset -20px -20px 14px 2px rgba(0, 0, 0, .2);
      animation-name: myopacity;
      animation-duration: 5000000s;
    }

    @keyframes myrotate {
      0% {
        transform: rotatez(0deg);
      }
      100% {
        transform: rotatez(360deg);
      }
    }

    @keyframes myopacity {
      0% {
        background-position: 0px;
        transform: rotatez(0deg);
      }
      50% {
        background-position: 100000000px;
      }
      100% {
        background-position: 0;
        transform: rotatez(-360deg);
      }
    }

&lt;!-- language: lang-html --&gt;

    &lt;div class=&quot;wrapper&quot;&gt;
      &lt;div class=&quot;planet&quot;&gt;&lt;/div&gt;
    &lt;/div&gt;

&lt;!-- end snippet --&gt;

And this:

&lt;!-- begin snippet: js hide: true console: true babel: false --&gt;

&lt;!-- language: lang-css --&gt;

    body {
      background: #131418;
    }

    .wrapper {
      margin: 1em;
      max-width: 100%;
      position: fixed;
      left: 50%;
      top: 50%;
      transform: translate(-50%, -50%);
    }

    .planet,
    .planet:before,
    .planet:after {
      height: 500px;
      width: 500px;
      max-height: 30vw;
      max-width: 30vw;
      border-radius: 100vw;
      will-change: transform;
    }

    .planet {
      box-shadow: inset 0px 0px 100px 10px rgba(0, 0, 0, .5);
      position: relative;
      float: left;
      margin: 0 2em;
    }

    .planet,
    .planet:before,
    .planet:after {
      animation-name: myrotate;
      animation-duration: 10s;
    }

    .wrapper,
    .planet,
    .planet:before,
    .planet:after {
      animation-timing-function: linear;
      animation-iteration-count: infinite;
    }

    .planet:before,
    .planet:after {
      content: &#39;&#39;;
      position: absolute;
      top: 0;
      left: 0;
    }

    .planet:before {
      box-shadow: inset 50px 100px 50px 0 rgba(0, 0, 0, .5), 0 0 50px 3px rgba(0, 0, 0, .25);
      background-image: -webkit-radial-gradient( top, circle cover, #ffffff 0%, #000000 80%);
      opacity: .5;
    }

    .planet:after {
      opacity: .3;
      background-image: -webkit-radial-gradient( bottom, circle, #ffffff 0%, #000000 -200%);
      box-shadow: inset 0px 0px 100px 50px rgba(0, 0, 0, .5);
    }

    @keyframes myrotate {
      0% {
        transform: rotatez(0deg);
      }
      100% {
        transform: rotatez(-360deg);
      }
    }

    .bg {
      background: wheat;
    }

&lt;!-- language: lang-html --&gt;

    &lt;div class=&quot;wrapper&quot;&gt;
      &lt;div class=&quot;planet bg&quot;&gt;&lt;/div&gt;
    &lt;/div&gt;

&lt;!-- end snippet --&gt;

Which are okay until you try to actually rotate them on either the **x-axis** or the **y-axis** like the cube in my first example...here&#39;s what happens then: (simplified example)

&lt;!-- begin snippet: js hide: true console: true babel: false --&gt;

&lt;!-- language: lang-css --&gt;

    .sphere {
      background: black;
      width: 300px;
      height: 300px;
      border-radius: 100vw;
      animation: myrotate 10s linear infinite
    }

    @keyframes myrotate {
      0% {
        transform: rotate3d(0, 0, 0, 0);
      }
      100% {
        transform: rotate3d(0, 1, 0, 360deg);
      }
    }

&lt;!-- language: lang-html --&gt;

    &lt;div class=&quot;sphere&quot;&gt;&lt;/div&gt;

&lt;!-- end snippet --&gt;


All you get is a flat 2d object - which is expeceted considering that it&#39;s what the element is


----------


The closest thing I found is the following shape created in a [tutorial by Timo Korinth][1] 

&lt;!-- begin snippet: js hide: true console: true babel: false --&gt;

&lt;!-- language: lang-css --&gt;

    @-webkit-keyframes animateWorld {
      0% {
        -webkit-transform: rotateY(0deg) rotateX(0deg) rotateZ(0deg);
      }
      50% {
        -webkit-transform: rotateY(360deg) rotateX(180deg) rotateZ(180deg);
      }
      100% {
        -webkit-transform: rotateY(720deg) rotateX(360deg) rotateZ(360deg);
      }
    }

    html {
      background: #FFFFFF;
    }

    . world {
      -webkit-perspective: 1000px;
    }

    .cube {
      margin-left: auto;
      margin-right: auto;
      position: relative;
      width: 200px;
      height: 200px;
      -webkit-transform-style: preserve-3d;
      -webkit-animation-name: animateWorld;
      -webkit-animation-duration: 10s;
      -webkit-animation-iteration-count: infinite;
      -webkit-animation-timing-function: linear;
    }

    .circle {
      position: absolute;
      width: 100%;
      height: 100%;
      border: 2px dashed #009BC2;
      border-radius: 50%;
      opacity: 0.8;
      background: rgba(255, 255, 255, 0);
    }

    .zero {
      -webkit-transform: rotateX(90deg);
    }

    .two {
      -webkit-transform: rotateY(45deg);
    }

    .three {
      -webkit-transform: rotateY(90deg);
    }

    .four {
      -webkit-transform: rotateY(135deg);
    }

    .five {
      width: 173px;
      height: 173px;
      margin: 14px;
      -webkit-transform: rotateX(90deg) translateZ(50px);
    }

    .six {
      width: 173px;
      height: 173px;
      margin: 14px;
      -webkit-transform: rotateX(90deg) translateZ(-50px);
    }

&lt;!-- language: lang-html --&gt;

    &lt;div class=&quot;world&quot;&gt;
      &lt;div class=&quot;cube&quot;&gt;
        &lt;div class=&quot;circle zero&quot;&gt;&lt;/div&gt;
        &lt;div class=&quot;circle one&quot;&gt;&lt;/div&gt;
        &lt;div class=&quot;circle two&quot;&gt;&lt;/div&gt;
        &lt;div class=&quot;circle three&quot;&gt;&lt;/div&gt;
        &lt;div class=&quot;circle four&quot;&gt;&lt;/div&gt;
        &lt;div class=&quot;circle five&quot;&gt;&lt;/div&gt;
        &lt;div class=&quot;circle six&quot;&gt;&lt;/div&gt;
      &lt;/div&gt;
    &lt;/div&gt;

&lt;!-- end snippet --&gt;


----------


So here&#39;s my 

Question:
--------

**How do I create an actual 3 dimensional sphere with pure CSS? More specifically, one that is covered - not just a frame - and doesn&#39;t involve hundreds of html elements.** 


----------



**Notes:**  

 1. Three dimensional spheres have **height, width and depth** -  just
    like the cube in my first example snippet
 2. I don&#39;t need any physics and there&#39;s no need for any
    user-interaction. Just an animated spinning sphere.

----------


**Additional resources:**

 1. [paulrhayes.com - Spheres](https://paulrhayes.com/experiments/sphere/)
 2. [&lt;s&gt;3d&lt;/s&gt; (2d illusion) Earth with Rotating Animation with CSS][2]
 3. [Interactive CSS sphere][3]




  [1]: http://timokorinth.de/css-3d-sphere/
  [2]: http://w3bits.com/css-earth/
  [3]: http://robosparrow.github.io/Css3dSphere/


Content Type	Original Author	Original Content on Stackoverflow
Question	abernier	View Question on Stackoverflow
Solution 1 - Performance	Cameron Little	View Answer on Stackoverflow
Solution 2 - Performance	AFCA_Timon	View Answer on Stackoverflow
Solution 3 - Performance	roman	View Answer on Stackoverflow

translate3d vs translate performance

Performance Problem Overview

Performance Solutions

Solution 1 - Performance

Solution 2 - Performance

Solution 3 - Performance

Adding offset to {{@index}} when looping through items in Handlebars

SonarQube not picking up Unit Test Coverage

Attributions