Look around and you will see an evolution of forms going on. For billions of years, those shapes are brushed against each other and against nothing else. Some have managed to be present on this very day. A hominid body is one example, a common rock's or a star's shape are another. There are no guarantees however, how long they will last in this constantly changing world.

What do we get, if we start the same process -- not inside the real world -- but inside of an artificial world of digital bit strings, carved into the computer memory?

The general law is the same. More prolific forms will fill the space. We can manipulate the process by setting the initial conditions and the law, by which one shape is more resilient to passing time, than another one.

Critticall is such a humble simulation of a digital world, where algorithms are created by a random change and where they survive and evolve according to some simple criteria. Like how few steps does it takes, or/and how few lines are needed to do the same thing, as the original one does. Or even how small some variables become.

This way, any code segment is melted and driven through many generations, till it may not be even recognizable any more. But still giving exactly the same result, as the initial algorithm. Except it's faster or with fewer lines.

From an algorithm, a more optimal one is usually evolved. Sometimes never seen by a human eye before and never imagined by anyone. Streamlining the architecture of an algorithm, not only it becomes ever more optimized, it becomes what we consider as a new.

Critticall is a toy AI, with many serious and profound results.

45 characters description
Optimizes algorithms written in a C dialect.

80 characters description
On the Evolution Algorithm based streamliner for "strict C" code segments.

250 characters description
Critticall is a digital environment, where an input algorithm is a subject to a digital evolution. The fitness may be the speed or the length of the code. Ever better algorithms are surviving small random changes and are the output result.

450 characters description
Critticall runs Evolution (Genetic) Algorithm on the program lines themselves. Any well defined code segment in the "strict C" language, can potentially be significantly improved. Often to a stage, never seen before. New sorting and compressing algorithms may, and do come out in the form of a source code, ready to compile. Even starting with an "empty" algorithm, just with a desired result specified, a working algorithm can be found.

2000 characters description
Critticall is an automated way, to improve, or even to invent a digital algorithm, or only a small segment of code. Initially, the desired output for the input must be specified. By giving the input and a known algorithm, or by specifying: if (input==0) {output=0;}, if (input==1) {output=1;}, if (input==2) {output=4;}, ... Critticall will improve this naive algorithm to something like output=input*input; - eventually! By the default, among several equivalent algorithms, those with a smaller computational complexity are favored. Through thousands or millions of generations, faster and faster algorithms are selected. Usually, the output is everything what they share with the initial algorithm. There is more. You can specify, that the number of lines should be minimized, regardless of how fast the execution is. This may give you a glimpse, on what a complicated code is in fact doing. Further, you can weight the commands by your own choice. This is useful to substitute a heavy command with a string of others. Additionally, you can penalize certain program variable, instead of commands. This a powerful feature, which enables a goal directed evolution, to a better and better predictor program, for example. Everything what is expressible in the Critticall language (which also expands), can be reshaped and studied with this toy AI tool, which used properly, causes a havoc among ones favorites program lines. But doing so, it gives you fast and efficient practical solutions. With Critticall, you can do things, very much beyond your algorithms devising power, no matter how high it may be. Just subject your lines of code to Critticall, and watch what is happening to them. You can investigate deep and broad among fundamentals of the computing science.