What is Happening 5

Follow @PistonDeveloper at Twitter!

Shush! It has been 4 months since last blog post, how times fly by when you do not notice!

In this post I will give a summary on some projects, and then go into more details about some new research!


List of contributors (32)


Conrod is an UI framework that makes it easy to program UIs in Rust.

  • New triangles primitive widget
  • Improved touch experience
  • Lots of bug fixed

List of contributors (66)


Image is a very popular image library with pure-Rust encoders and decoders.

  • Improved BMP support
  • Lots of bug fixed

List of contributors (95)


Imageproc is a library for image processing.

  • Support seam carving for color images
  • Sobel gradient for color images
  • Improved performance
  • More tests and documentation

List of contributors (16)


  • Fixed incremental build

List of contributors (14)


Dyon is a scripting language with lifetime checker instead of garbage collection, a similar object model to Javascript and lots of other features useful for gamedev.

Starting a new project to make a Dyon to Rust transpiler: https://github.com/pistondevelopers/dyon_to_rust

List of contributors (4)


  • Support for playing sounds in addition to music
  • Change volume on both music and sound

List of contributors (3)


AdvancedResearch is a collection of projects that explore new ideas and concepts. This is moved to its own organization to not spam PistonDevelopers with emails.

Here are some things that happened since last blog post:

Homotopy maps are functions normalized between 0 and 1 on input and generate points that are continuously connected with each other. I found this idea very cool because you can use them for rendering directly without any extra knowledge. The challenge is to find the right API design so you get the best from both worlds of graphical editors and programming.

At perfect intelligence, problems get solved at the information theoretic optimal performance. I used the tools of path semantics to reason about how this might work, but have not formalized it yet (I lack the right conceptual tools!). Surprisingly it is kind of like binary search, but instead of sorting the algorithm need to arrange sub-types. You can order a T-shirt with the symbols of the first steps ∃f{} (it is called a “universal existential path”).

Probabilistic paths: A new discovery

formula for probabilistic paths

Here is a thought experiment designed to help you understand what it is about:

  1. Take a lot of monkeys
  2. Make them type randomly on a keyboard
  3. What is the chance one of them recreates Shakespeare (or Harry Potter)?

Using standard probability theory, it is easy to compute this chance, even we never will get the opportunity to test it out in practice, because it is very, very tiny.

monkey typing on keyboard

In principle, there is a correct probability for any similar question we can ask, no matter how complex the experiment is and how long time it takes to complete.

If you put the same monkeys to play Super Mario, what is the chance one of them will win? We do not know that yet, because the code of Super Mario is much more complex than the first example. Using standard formulas for probability distributions will not get you very far. What we need a different way of thinking about probabilities that can be interpreted from programs.

A probabilistic path is a transform of the source code of e.g. Super Mario, such that you can compute how likely a monkey is to win the game.

In additon you need:

  1. A function describing how likely a given input is
  2. A function describing what is a winning condition from the output

A huge breakthrough in path semantics happened by extending the theory to probabilities of finite sets. Now I got a higher order path semantical function that solves similar problems to the one above. It is called “probabilistic path” in the language of path semantics.

I tested it on very simple things, because it is very hard to use on complex algorithms. One open problem is how describe in a meaningful way why the algorithm is allowed to sum positive and negative numbers while always ending up in the valid probability range between 0 and 1.

What is Happening 4

Follow @PistonDeveloper at Twitter!

Here are some of the things that happened since the last post:


Advanced research focuses on making conceptual breakthroughs in system thinking. The previous advanced research under the Piston project is moving to this new open source organization. You can read about the rationale of separating this research from the Piston project here.

Some bullet points of the overall progress:

  • New approach to mathematical foundation of friendly artificial intelligence nicknamed “golden rationality”
  • Some progress on path semantics and generalizations to probability theory
  • Gini solvers could balance economic inequality (can be tested in MMOs)
  • Established contact with scientists and engineers about mitigating climate change

Golden rationality is a very recent topic, where I try avoiding the scary first order approximation to friendly superintelligence and instead focus on human value approximation concerning group strategies. This means it is not about superintelligence “in a box”, but about beating the efficiency of individual rational agents in a world where AI is standardized and utilized by many people. For discussion and questions, open up an issue here.

Normal research related to gamedev will continue under the Piston project.


  • New CollapsibleArea widget
  • Improved performance
  • Added crates.io categories
  • Various bug fixes and improvements

List of contributors (59)


There is an internal compiler bug on Rust 18 Beta, so if you have troubles compiling your project, you might want to use Right stable or nightly instead.

  • Simple BMP support
  • PPM support
  • New constructor for adjusting quality of JPEG encoding

List of contributors (89)


  • Improved performance, incluing better parallization using Rayon
  • Added more benchmarks
  • Ellipse and bezier drawing
  • Various bug fixes and improvements

List of contributors (14)


  • New intrinsics
  • Optional namespaces with shared aliases
  • Link loop (a loop that concatenates body expressions using Dyon’s link data structure)
  • Try expressions (turning errors into result)
  • Various bug fixed and improvements

List of contributors (4)


  • Cargo support
  • Support for both Visual Studio 2015 and 2017
  • Various bug fixes and improvements

List of contributors (14)

Other projects

  • New versions of Gfx has been updated through the ecosystem
  • resize has gotten nice upgrades and performance improvements
  • music now supports sound clips

Announcing Dyon-Snippets

The Piston project is pleased to announce Dyon-Snippets, a place to share Dyon source code and discuss library design!

Dyon is scripting programming language started in 2016 by myself (Sven Nilsen, bvssvni).

Dyon started as an experiment in a period I had a lot of time, while waiting for some important Gfx redesigns. After a week of coding, I discovered that it was possible to use a lifetime checker (like Rust), but without borrow semantics (unlike Rust) instead of a garbage collector. Combined with copy-on-write for non-stack references, this creates a very limited memory model but sufficient enough for many practical applications. It is difficult to write object oriented code in Dyon, but it is very nice for iterating over arrays.

  • Built-in support for 4D vectors and HTML colors
  • Packed loop for mathematical index notation
  • Secrets (more about this later)

The language uses dynamic loading of modules to organize code, where you have full control over module dependencies. It is very common to write a loader script, a program that runs before you run the actual program.

Here is an example:

fn main() {
    foo := unwrap(load("foo.dyon")) // Load `foo`.
    bar := unwrap(load(source: "bar.dyon", imports: [foo])) // Load `bar` with `foo` as dependency.
    call(bar, "main", []) // Run the function `main` on the `bar` module.

This allows a kind of programming where you easily control how stuff gets loaded, e.g. check for for updates or refresh a module every Nth second.

I often use Dyon for problem solving, because the language has a feature called “secrets”. A secret is a hidden array of values associated with a bool or f64. The type is sec[bool] or sec[f64]. The indexed loops in Dyon are integrated with secrets.

For example, you have a 2D array v and compute the maximum value:

m := max i, j {v[i][j]}
println(m) // Prints maximum value of `v`.

Dyon infers the range from the loop body. The code above is equivalent to:

m := max i [len(v)), j [len(v[i])) {v[i][j]}

This is a packed loop which is equivalent to:

m := max i [len(v)) {max j [len(v[i])) {v[i][j]}}

The notation max i, j {v[i][j]} is inspired by mathematics. In mathematics and physics it is very common to use indices and custom loops. It is easy to translate back and forth between equations and Dyon code, and it helps you learn mathematics as well!

The type of m is sec[f64]. You can write the following:

where_max := where(max)
println(where_max) // Prints `[i, j]`.

This is how it works:

  1. The inner max loop returns the maximum value with a secret [j].
  2. The outer max loop finds the maximum inner value and changes the secret to [i, j].

A secret propagates from the left argument in binary operators. This means you can combine any and all loops with max and min:

// Is there any list which maximum value is larger than 10?
m := any i {max j {v[i][j]} > 10}
if m {
    println(why(m)) // Prints `[i, j]`.

In problem solving this is very convenient, because many problems can be thought of as formulating a question. When you know the right question to ask, the answer is often easy to find.

Older Newer