Blue Tomato

From Esolang
Jump to navigation Jump to search

Blue tomato (BT) is an art programming language concepted by user:Jabutosama. The language is based around around giving more or less surreal art to very specifically teached pattern-regonition ai. The language itself is simply the abstract format or way the art is drawn to make the bot to do the given task.


There will be a machine learning based pattern regonition bot program to analyse any given picture. The bot will generate internal machine code based on the data given, and then execute immediately. Also the bot should have opinion for only outputting machine code in text form instead.

The bot is trained during the language implementation process and stays constant after release. Any modifications on the bot should be labeled **BT-(versiontype)-(versionnumber)** or something which achieves the obivious distinctness goal.

Without any context, Blue Tomato will stand for the first implemented, original language. Because the relationship between image content and the resulting code can be shady and be questionable at best, the language is meant to stay as artlang. Any actual application-based pattern regonition languages should not be directly inherited from TB as it would fight against the idea of artlang, instead they should be their own languages.

As said, the main purpose of the language is to entertain as a sport of finding cool ways to execute programs, way to learn how pattern regonition works and to be just simply as esoteric as damn.


More specific details and notes for the first design of Blue Tomato.

Pattern Table

Pattern name Pattern Definition resulting data
Rectangle rectangle closing an area enclosed block
Circle ellipse closing an area integer value
Relation straight, thick lines functional relationship
Arrow same as lines, but with triangle on end program flow relation
Cross two, short, adjecent lines marker

Program Flow

The code forms a graph which is then executed as in any graph-based language. Biggest shapes are opted to come out earlier than smaller ones and then others closest to top-right corner. Program flows from first block to the next ones through arrows relations.

Enclosed blocks represent nodes and can hold either sub-graphs or ellipses. Ellipses form integers in same way as set theory defines numbers as sets of sets. If there is an ellipse containing a star, the outer integer will be negative. Ellipses in same container or ellipse will be always multiplied in runtime.

When program execution enters a node, any sub-graphs will be executed before the execution continues. Any sub-graphs will be collapsed to final integers contained and the node virtually vanishes. In case the number is not zero, the execution follows to next arrow-direction nodes, and in case the arrow overlaps a cross, the numeric value is passed and virtually added to it.

With this more or less nonsensical graph language, writer Jabutosama postulates the language to be turing-complete, but has no proofs for such.

The language can be extended further by adding color, texturial, content and symbolic pattern matching.