One concept related to Turing completeness involves the famous halting problem.

This implies that if CSS were to be considered Turing complete, there would not exist a universal method for determining whether a CSS program will terminate its execution or continue indefinitely.

However, we can actually devise such a method specifically for CSS! Here's how:

• If the stylesheet does not include any animations, then it will eventually stop running.

• If animations are present, then:

  • If any animation-iteration-count is set to infinite, and the corresponding selector is matched in the HTML, then it will keep looping endlessly without halting.

  • Otherwise, it will eventually halt.

In conclusion, as we have successfully addressed the halting problem within the context of CSS, it logically follows that CSS is not Turing complete.

(It has been pointed out by Daniel Wagner that considerations besides animations, like selector matching or layout, could potentially contribute to achieving Turing completeness. Nonetheless, formal arguments supporting this remain challenging, but I will attempt to explain why such an occurrence is improbable.)

Firstly: Languages that are Turing complete have mechanisms for recursively feeding data back into themselves. However, the structure of CSS itself inhibits this feedback loop:

• @media queries only assess properties of the browser environment, such as viewport dimensions or screen resolution. While these properties may vary due to user actions or JavaScript manipulation (e.g., resizing the window), they cannot be altered solely through CSS directives.

• The pseudo-elements ::before and ::after are considered separate from the DOM structure and thus pose limitations on possible interactions.

• Selector combinators facilitate inspections of elements above or preceding the current element, hence preventing cyclic dependencies.

• Although it is feasible to hover over an element and trigger behaviors like moving it, the computed changes occur only with ongoing mouse movement.

This rationale should convince you that solely relying on selector matching is insufficient to achieve Turing completeness. What about layout functionalities?

The intricate nature of modern CSS layouts involving techniques like Flexbox and Grid adds complexity to the scenario. Even supposing infinite loops could somehow be triggered through layout operations, capitalizing on this for practical computations would prove arduous. This difficulty arises from CSS selectors addressing only internal structural aspects of the DOM rather than real-time screen arrangement. Thus, any argument asserting Turing completeness via layout functions must rely exclusively on layout components.

Lastly – and critically important – browser developers intentionally maintain CSS as non-Turing complete. By imposing constraints on the language, developers foster opportunities for efficient optimizations that enhance web performance universally. Moreover, Google allocates significant resources, like an entire server farm, towards identifying bugs in Chrome. If a loophole existed allowing for indefinite loops using CSS, it would likely have been detected already 😉

According to the source I found, it's clear that CSS is not Turing complete. The article makes a strong case against trying to make it one.

In one insightful comment from the article:

Indeed, I don't believe that CSS has the characteristics of being Turing complete. The absence of functions in CSS prevents the possibility of writing an interpreter, an essential component for a system to be considered Turing-complete. With no direct access to variables or the ability to represent program structures in CSS, achieving Turing completeness seems unattainable.

This response is incorrect as it blends descriptions of UTM with the Universal Turing Machine itself.

While we do have a solid response from a different angle, it does not directly highlight the flaws in the current top answer.

Let's start by acknowledging that humans can function as a UTM. This implies that if we were to do:

CSS + Human == UTM

The CSS component becomes redundant since all tasks can be carried out by the Human who will perform the UTM task. The act of clicking could serve as a UTM because clicks are targeted rather than random.

Instead of CSS, I might utilize this text (Rule 110):

000 -> 0
001 -> 1
010 -> 1
011 -> 1
100 -> 0
101 -> 1
110 -> 1
111 -> 0

To direct my actions with the same outcome. Consequently, is this text a UTM? No, it merely serves as input (description) for other UTMs (be it human or computer) to decipher and execute. Clicking alone is sufficient to operate any UTM.

The key deficiency in CSS is its inability to autonomously modify its state arbitrarily. If CSS had the capability to trigger clicks, then it would qualify as a UTM. The argument that your clicks act as a "crank" for CSS is inaccurate since the real "crank" for CSS is the Layout Engine that powers it, serving as ample evidence that CSS is indeed a UTM.

One of the key challenges presented here is that a machine coded in HTML+CSS lacks the ability to process an infinite number of steps (meaning true recursion is not possible) unless the code itself is of infinite length. The inquiry of whether this machine will achieve configuration H within n steps or fewer can always be definitively answered as long as n is a finite value.

Turing completeness goes beyond just "defining functions" or "having ifs/loops/etc". For instance, Haskell lacks "loop", lambda-calculus lacks "ifs", and so on...

One interesting example is showcased on this website: . The author demonstrates creating a "FizzBuzz" program in Ruby using only closures (without utilizing strings, numbers, or any other data types)...

There are instances where individuals have managed to perform arithmetical computations in Scala solely through the type system

Therefore, I believe that CSS3+HTML can be considered turing-complete (even though practical computation may not be feasible without driving oneself insane)

Did you know that CSS is considered Turing-complete? And the most interesting part is, it doesn't need any user interaction to execute programs.

Believe it or not, in CSS you can actually run finite Boolean circuits and even Turing machines, as long as there is a stationary mouse cursor available to activate the :hover rules. It's quite fascinating how CSS can handle such complex operations!

Check out this link for more information on CSS being Turing-complete.

Just so you know, these samples were personally developed by me. To my knowledge, this is one of the first fully functional Turing machines created using pure CSS.