iAmGio / pikt

Ah a language to code by while listening to Pink Floyd - a guy from Reddit

This looks like it belongs on the list of those things I totally want to do if I ever become immortal - another guy from Reddit

Pikt is a pixel-based, Turing complete esoteric programming language that generates fast and lightweight programs out of aesthetically pleasant image sources. Indeed, Pikt's most interesting feature is flexibility: every keyword, statement, function, operator and so on is linked to one - or more - color, which can be easily customized via color schemes.

Pikt compiles executables via the Kotlin compiler, therefore compilation for both JVM and native* targets is available, along with runtime interpretation.

Make sure to check out the wiki to learn how to create your first Pikt program!

* Native support is limited due to the lack of Kotlin/Native libraries and is being discontinued.

A high-performance Fibonacci sequence algorithm.


A prime numbers algorithm.


A string reverser.


A tree that prints "A tree!".

These examples use custom color schemes.
Click on the examples for a breakdown/explanation.

Table of contents

• Properties
• Settings arguments
• Command arguments
• Building
• Roadmap

Properties

The following properties define parameters needed by Pikt.
Example: java -Dproperty=value -jar pikt.jar -argument.

• -Dsource source image file;

• -Doutput output name without extension. It will take source name without extension if not specified;

• -Dcolors path to the .properties color scheme without extension.
  Default values will be used if not specified (not recommended);

• -Dtargets compilation targets divided by a comma. Can be jvm, windows, osx or linux. Note that Windows and OSX executables can be generated only on those platforms. No compilation will be executed if not specified;

• -Dlib path to JAR libraries, including the bundled stdlib.jar file, divided by a comma. If not specified, points by default to ./libraries/stdlib.jar;

• -Djvmcompiler path to the Kotlin/JVM (kotlinc) executable compiler. Required if target contains jvm or if -interpret is used;

• -Dnativecompiler path to the Kotlin/Native (kotlinc) executable compiler. Required if target contains a native target;

• -Dproject optional path to a project info YAML configuration.

• -Dtask optional task name (defined within a project info configuration) to be executed.

Settings arguments

The following arguments enable settings that affect Pikt's behavior.

• -interpret runs the generated code via the JVM compiler;

• -printoutput prints the generated Kotlin code;

• -nocompile prevents the generation of any executable file;

• -pixelinfo adds information about pixel coordinates to the output code as comments;

• -imgoutput=path sets the output file for image-generating commands (see below). If not specified, defaults to the source image path followed by a suffix.

Command arguments

The following arguments execute tasks and exit when completed.

• -downloadcompiler=type[,version] downloads the zipped Kotlin compiler for the given platform (jvm, windows, macos, linux).
  version defaults to 1.6.10.

• -createscheme creates a new color scheme with default values.
  It automatically appends library colors too, i.e. as the stdlib scheme, loaded from -Dlib;

• -exportscheme generates a useful color palette image out of the given color scheme;

• -recolorize[=method] creates a copy of the source image (that relies on the default scheme) and adapts it to a custom scheme (specified by -Dcolors).
  method defines the way properties with more than one color are handled; it can be either first (default), last or random;

• -standardize creates a copy of the source image (that relies on a custom scheme) and adapts it to the default scheme;

• -compact[=size] creates a compacted copy of the source image.
  If size is not specified, it will try to create a square-ish image with no whitespaces.
  size can be defined via w?h?, where both wand h are optional (in case one is missing, it will be calculated the same way as before) (e.g. w10h5, w10, h5);

• -decompact creates a decompacted copy of the source image with a statement per line;

• -standardecompact runs -standardize + -decompact;

• -colorswap=<swaps> swaps colors from the source image.
  swaps is defined as from1:to1,from2:to2,... where from and to are hexadecimal colors.

• -mask=path creates a masked copy of the source image, loading the mask image from path;

• -strconvert=string converts a string into a sequence of RGB (grayscale) values supported by Pikt and prints them out.
  See Hello world! for further information.
  For instance, -strconvert="Hello Pikt!" prints:

RGB:  72  101  108  108  111  32  80  105  107  116  33  
      H   e    l    l    o        P   i    k    t    !   

• -welcome runs -createscheme, -exportscheme (both on colors) and -downloadcompiler=jvm. Its output is already zipped in the downloadable archive.

Commands can be chained. For example, java -Dsource=img.png -Dcolors=scheme -jar pikt.jar -imgoutput=img_new.png -recolorize -compact applies the scheme color scheme to img.png and compacts the output to img_new.png at the same time.

It is possible to overwrite the source image, albeit highly discouraged.

Building

The downloadable archive is already built off the latest GitHub commit. If you wish to build it yourself from source just run mvn clean install.

As a bonus tip, consider setting your run configuration to execute mvn clean install -pl stdlib -am in order to compile the standard library before launching Pikt.
If you are using IntelliJ IDEA consider importing configuration templates from the runConfigurations folder.

Roadmap

Code

• Variables
• Constants
• Function calls (both as part of expressions and standalone)
• Function definition
• If / else / if else
• Lambdas
• Operators (equality, logical and arithmetic)
• Loops (for-each + range function for indexed for loop)
• Try/catch
• Structs
• Standard library (2%, see CONTRIBUTING for contribution guidelines)
• External libraries support (following certain standards, wiki in progress)

Generation

• Compilation (JVM and Native)
• Interpretation (JVM)
• Error handling
• Runtime information