enilsen16 / ponyc

:horse: Pony is an open-source, actor-model, capabilities-secure, high performance programming language

Getting help

Need help? Not to worry, we have you covered.

We have a couple resources designed to help you learn, we suggest starting with the tutorial and from there, moving on to the Pony Patterns book. Additionally, standard library documentation is available online.

• Tutorial.
• Pony Patterns cookbook is in progress
• Standard library docs.
• Build Problems, see FAQ Compiling.

If you are looking for an answer "right now", we suggest you give our IRC channel a try. It's #ponylang on Freenode. If you ask a question, be sure to hang around until you get an answer. If you don't get one, or IRC isn't your thing, we have a friendly mailing list you can try. Whatever your question is, it isn't dumb, and we won't get annoyed.

• Mailing list.
• IRC.

Think you've found a bug? Check your understanding first by writing the mailing list. Once you know it's a bug, open an issue.

• Open an issue

Trying it online

If you want a quick way to test or run code, checkout the Playground.

Editor support

• Sublime Text: Pony Language
• Atom: language-pony
• Visual Studio: VS-pony
• Visual Studio Code: vscode-pony
• Vim:
  • vim-pony
  • pony.vim
  • currycomb: Syntastic support
  • SpaceVim, available as layer for Vim and Neovim. Just follow installation instructions then put call SpaceVim#layers#load('lang#pony')inside configuration file ($HOME/.SpaceVim.d/init.vim)
• Emacs:
  • ponylang-mode
  • flycheck-pony
  • pony-snippets
• BBEdit: bbedit-pony
• Micro: micro-pony-plugin
• Nano: pony.nanorc file
• Kate: update syntax definition file: Settings -> Configure Kate -> Open/Save -> Modes & Filetypes -> Download Highlighting Files

Installation

Pony supports LLVM 3.9 and on an experimental basis it supports LLVM 4.0 and 5.0. In addition, support for OpenSSL 1.1.0 was recently added for systems such as the Debian Stretch and Arch Linux, see FAQ Compiling for additional information.

Using Docker

Want to use the latest revision of Pony source, but don't want to build from source yourself? You can run the ponylang/ponyc Docker container, which is created from an automated build at each commit to master.

You'll need to install Docker using the instructions here. Then you can pull the latest ponylang/ponyc image using this command:

docker pull ponylang/ponyc:latest

Then you'll be able to run ponyc to compile a Pony program in a given directory, running a command like this:

docker run -v /path/to/my-code:/src/main ponylang/ponyc

If you're unfamiliar with Docker, remember to ensure that whatever path you provide for /path/to/my-code is a full path name and not a relative path, and also note the lack of a closing slash, /, at the end of the path name.

Note that if your host doesn't match the docker container, you'll probably have to run the resulting program inside the docker container as well, using a command like this:

docker run -v /path/to/my-code:/src/main ponylang/ponyc ./main

If you're using docker-machine instead of native docker, make sure you aren't using an incompatible version of Virtualbox.

Docker for Windows

Pull the latest image as above.

docker pull ponylang/ponyc:latest

Share a local drive (volume), such as c:, with Docker for Windows, so that they are available to your containers. (Refer to shared drives in the Docker for Windows documentation for details.)

Then you'll be able to run ponyc to compile a Pony program in a given directory, running a command like this:

docker run -v c:/path/to/my-code:/src/main ponylang/ponyc

Note the inserted drive letter. Replace with your drive letter as appropriate.

To run a program, run a command like this:

docker run -v c:/path/to/my-code:/src/main ponylang/ponyc ./main

To compile and run in one step run a command like this:

docker run -v c:/path/to/my-code:/src/main ponylang/ponyc sh -c "ponyc && ./main"

Docker and AVX2 Support

By default, the Pony Docker image is compiled without support for AVX CPU instructions. For optimal performance, you should build your Pony installation from source.

Linux using an RPM package (via COPR)

For Red Hat, CentOS, Oracle Linux, Fedora Linux, or OpenSuSE, the release builds are packaged and available on COPR (ponylang/ponylang).

Using yum for Red Hat, CentOS, Oracle Linux and other RHEL compatible systems:

yum copr enable ponylang/ponylang epel-7
yum install ponyc

See https://bugzilla.redhat.com/show_bug.cgi?id=1581675 for why epel-7 is required on the command line.

Using DNF for Fedora Linux:

dnf copr enable ponylang/ponylang
dnf install ponyc

Using Zypper for OpenSuSE Leap 15:

zypper addrepo --refresh --repo https://copr.fedorainfracloud.org/coprs/ponylang/ponylang/repo/opensuse-leap-15.0/ponylang-ponylang-opensuse-leap-15.0.repo
wget https://copr-be.cloud.fedoraproject.org/results/ponylang/ponylang/pubkey.gpg
rpm --import pubkey.gpg
zypper install ponyc

Using Zypper for OpenSuSE Tumbleweed:

zypper addrepo --refresh --repo https://copr.fedorainfracloud.org/coprs/ponylang/ponylang/repo/opensuse-tumbleweed/ponylang-ponylang-opensuse-tumbleweed.repo
wget https://copr-be.cloud.fedoraproject.org/results/ponylang/ponylang/pubkey.gpg
rpm --import pubkey.gpg
zypper install ponyc

RPM and AVX2 Support

By default, the Pony RPM package is compiled without support for AVX CPU instructions. For optimal performance, you should build your Pony installation from source.

Ubuntu Linux using a DEB package (via Launchpad PPA)

For Ubuntu Linux (Trusty, Xenial, Artful, Bionic, Cosmic), the release builds are packaged and available on Launchpad PPA (ponylang/ponylang).

To install builds via Apt:

add-apt-repository ppa:ponylang/ponylang
apt-get update
apt-get install ponyc

NOTE: For Trusty, you will need to manually compile/install libpcre2 to use regex related functionality.

DEB and AVX2 Support

By default, the Pony DEB package is compiled without support for AVX CPU instructions. For optimal performance, you should build your Pony installation from source.

Debian Linux using a DEB package (via Bintray)

For Debian Linux, the release builds are packaged and available on Bintray (pony-language/ponyc-debian).

To install builds via Apt (and install Bintray's public key):

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys "D401AB61 DBE1D0A2"
echo "deb https://dl.bintray.com/pony-language/ponyc-debian pony-language main" | sudo tee -a /etc/apt/sources.list
sudo apt-get update
sudo apt-get -V install ponyc

You may need to install ponyc (current) instead of ponyc-release (deprecated). And if you have issues with package authentication you may need to comment out the deb line in /etc/apt/sources.list, do an update, and uncomment it again. Feel free to ask for help if you have any problems!

DEB and AVX2 Support

By default, the Pony DEB package is compiled without support for AVX CPU instructions. For optimal performance, you should build your Pony installation from source.

Gentoo Linux

layman -a stefantalpalaru
emerge dev-lang/pony

A live ebuild is also available in the overlay (dev-lang/pony-9999) and for Vim users there's app-vim/pony-syntax.

Linux using Linuxbrew

brew update
brew install ponyc

NixOS Linux or any OS using nix

nix-env -i ponyc

"cannot find 'ld'" error

If you get an error when trying to use ponyc to compile pony source that looks like this:

collect2: fatal error: cannot find 'ld'

you might have to install the ld-gold linker. It can typically be found by searching your distro's package repository for binutils-gold or just ld-gold.

Mac OS X using Homebrew

brew update
brew install ponyc

Windows using ZIP (via Bintray)

Windows users will need to install:

• Visual Studio 2017 or 2015 (available here) or the Visual C++ Build Tools 2017 or 2015 (available here), and
  • If using Visual Studio 2015, install the Windows 10 SDK (available here).
  • If using Visual Studio 2017 or the Visual C++ Build Tools 2017, install the latest Windows 10 SDK (10.x.x.x) for Desktop from the Visual Studio installer.

Once you have installed the prerequisites, you can download the latest ponyc release from bintray.

Building ponyc from source

First of all, you need a compiler with decent C11 support. The following compilers are supported, though we recommend to use the most recent versions.

• GCC >= 4.7
• Clang >= 3.4
• MSVC >= 2015
• XCode Clang >= 6.0

Pony requires LLVM version 3.9.1.

There is experimental support for building with LLVM 4.0.1, 5.0.1 or 6.0.0, but this may result in decreased performance or crashes in generated applications.

NOTE: If LLVM version < 5.0.0 is used, cpu feature avx512f is diabled automagically to avoid LLVM bug 30542 otherwise the compiler crashes during the optimization phase.

Compiling Pony is only possible on x86 and ARM (either 32 or 64 bits).

Building on Linux

Get Pony-Sources from Github (More Information about Set Up Git https://help.github.com/articles/set-up-git/ ):

sudo apt install git
git clone git://github.com/ponylang/ponyc

Arch

Install pony dependencies:

pacman -S llvm make ncurses openssl pcre2 zlib

To build ponyc and compile and helloworld:

cd ~/ponyc/
make default_pic=true default_ssl='openssl_1.1.0'
./build/release/ponyc examples/helloworld
./helloworld

Debian Jessie

Add the following to /etc/apt/sources:

deb http://llvm.org/apt/jessie/ llvm-toolchain-jessie-3.9 main
deb-src http://llvm.org/apt/jessie/ llvm-toolchain-jessie-3.9 main

Install the LLVM toolchain public GPG key, update apt and install packages:

wget -O - http://llvm.org/apt/llvm-snapshot.gpg.key|sudo apt-key add -
sudo apt-get update
sudo apt-get install make gcc g++ git zlib1g-dev libncurses5-dev \
                       libssl-dev llvm-3.9-dev

Debian Jessie and some other Linux distributions don't include pcre2 in their package manager. pcre2 is used by the Pony regex package. To download and build pcre2 from source:

wget ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre2-10.21.tar.bz2
tar xvf pcre2-10.21.tar.bz2
cd pcre2-10.21
./configure --prefix=/usr
make
sudo make install

To build ponyc, compile and run helloworld:

cd ~/ponyc/
make
./build/release/ponyc examples/helloworld
./helloworld

Debian Sid

Install pony dependencies:

sudo apt-get update
sudo apt-get install make gcc g++ git zlib1g-dev libncurses5-dev \
  libssl-dev llvm llvm-dev libpcre2-dev

To build ponyc, compile and run helloworld:

cd ~/ponyc/
make default_pic=true
./build/release/ponyc examples/helloworld
./helloworld

Ubuntu Trusty

Add the LLVM apt report to /etc/apt/sources.list. Open /etc/apt/sources.list and add the following lines to the end of the file:

deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.9 main
deb-src http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.9 main

Add the LLVM repo as a trusted source:

cd /tmp
wget -O llvm-snapshot.gpg.key http://apt.llvm.org/llvm-snapshot.gpg.key
sudo apt-key add llvm-snapshot.gpg.key

Install dependencies:

sudo apt-get update
sudo apt-get install -y build-essential git zlib1g-dev libncurses5-dev \
  libssl-dev llvm-3.9

Install libprce2:

cd /tmp
wget ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre2-10.21.tar.bz2
tar xjvf pcre2-10.21.tar.bz2
cd pcre2-10.21
./configure --prefix=/usr
make
sudo make install

Clone the ponyc repo:

cd ~/
git clone https://github.com/ponylang/ponyc.git

Build ponyc, compile and run helloworld:

cd ~/ponyc/
make
./build/release/ponyc examples/helloworld
./helloworld

Ubuntu Xenial

Add the LLVM apt repos to /etc/apt/sources.list. Open /etc/apt/sources.list and add the following lines to the end of the file:

deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-3.9 main
deb-src http://apt.llvm.org/xenial/ llvm-toolchain-xenial-3.9 main

Add the LLVM repo as a trusted source:

cd /tmp
wget -O llvm-snapshot.gpg.key http://apt.llvm.org/llvm-snapshot.gpg.key
sudo apt-key add llvm-snapshot.gpg.key

sudo apt-get update
sudo apt-get install -y build-essential git zlib1g-dev libncurses5-dev libssl-dev libpcre2-dev llvm-3.9

Clone the ponyc repo:

cd ~/
git clone https://github.com/ponylang/ponyc.git

Build ponyc, compile and run helloworld:

cd ~/ponyc/
make
./build/release/ponyc examples/helloworld
./helloworld

Ubuntu Artful

sudo apt-get update
sudo apt-get install -y build-essential git zlib1g-dev libncurses5-dev libssl-dev libpcre2-dev llvm-3.9

Clone the ponyc repo:

cd ~/
git clone https://github.com/ponylang/ponyc.git

Build ponyc, compile and run helloworld:

cd ~/ponyc/
make default_pic=true
./build/release/ponyc examples/helloworld
./helloworld

Fedora (25)

dnf check-update
sudo dnf install git gcc-c++ make openssl-devel pcre2-devel zlib-devel \
  llvm-devel ncurses-devel

To build ponyc, compile and run helloworld:

cd ~/ponyc/
make
./build/release/ponyc examples/helloworld
./helloworld

Fedora (26, 27, 28, Rawhide)

dnf check-update
sudo dnf install git gcc-c++ make openssl-devel pcre2-devel zlib-devel \
  llvm3.9-devel ncurses-devel libatomic

To build ponyc, compile and run helloworld:

cd ~/ponyc/
make default_ssl='openssl_1.1.0'
./build/release/ponyc examples/helloworld
./helloworld

CentOS/RHEL (7)

Install dependencies:

sudo yum install git gcc-c++ make openssl-devel pcre2-devel zlib-devel \
  ncurses-devel libatomic

Using LLVM 3.9.1 from EPEL:

wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
sudo yum install ./epel-release-latest-7.noarch.rpm
sudo yum install llvm3.9-devel llvm3.9-static

Using LLVM 3.9.1 from copr:

sudo yum install yum-plugin-copr
sudo yum copr enable alonid/llvm-3.9.1
sudo yum install llvm-3.9.1 llvm-3.9.1-devel llvm-3.9.1-static

Using LLVM 5.0.1 from copr:

sudo yum install yum-plugin-copr
sudo yum copr enable alonid/llvm-5.0.1
sudo yum install llvm-5.0.1 llvm-5.0.1-devel llvm-5.0.1-static

Using LLVM 4.0.1 from llvm-toolset-7 from SCL:

CentOS:

# 1. Install a package with repository for your system:
# On CentOS, install package centos-release-scl available in CentOS repository:
sudo yum install centos-release-scl

RHEL:

# On RHEL, enable RHSCL repository for you system:
sudo yum-config-manager --enable rhel-server-rhscl-7-rpms

# 2. Install the collection:
sudo yum install llvm-toolset-7 llvm-toolset-7-llvm-devel llvm-toolset-7-llvm-static

Enable the llvm collection before building:

scl enable llvm-toolset-7 bash

To build ponyc, compile and run helloworld:

cd ~/ponyc/
make use="llvm_link_static"
./build/release/ponyc examples/helloworld
./helloworld

OpenSUSE (Leap 42.3)

sudo zypper addrepo http://download.opensuse.org/repositories/devel:tools:compiler/openSUSE_Leap_42.3/devel:tools:compiler.repo
sudo zypper refresh
sudo zypper update
sudo zypper install git gcc-c++ make libopenssl-devel pcre2-devel zlib-devel \
  llvm3_9-devel binutils-gold

To build ponyc, compile and run helloworld:

cd ~/ponyc/
make
./build/release/ponyc examples/helloworld
./helloworld

OpenSuSE (Leap 15, Tumbleweed)

NOTE: LLVM 3.9 doesn't seem to be available so these instructions install the default LLVM version available.

sudo zypper install git gcc-c++ make libopenssl-devel pcre2-devel zlib-devel \
  llvm-devel binutils-gold

To build ponyc, compile and run helloworld:

cd ~/ponyc/
make
./build/release/ponyc examples/helloworld
./helloworld

Alpine (3.6, 3.7, Edge)

Install build tools/dependencies:

apk add --update alpine-sdk libressl-dev binutils-gold llvm3.9 llvm3.9-dev \
  pcre2-dev libexecinfo-dev coreutils linux-headers

To build ponyc, compile and run helloworld:

cd ~/ponyc/
make default_pic=true
./build/release/ponyc examples/helloworld
./helloworld

Other Linux distributions

You need to have the development versions of the following installed:

• 3.9.1
• zlib
• ncurses
• pcre2
• libssl

There is experimental support for LLVM 4.0.1 and 5.0.0, but this may result in decreased performance or crashes in generated applications.

If your distribution doesn't have a package for prce2, you will need to download and build it from source:

wget ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre2-10.21.tar.bz2
tar xvf pcre2-10.21.tar.bz2
cd pcre2-10.21
./configure --prefix=/usr
make
sudo make install

Finally to build ponyc, compile and run the hello world app:

cd ~/ponyc/
make
./build/release/ponyc examples/helloworld
./helloworld

Building on DragonFly

Dragonfly has been tested on 64-bit X86 DragonFly 4.8.

First, install the required dependencies:

sudo pkg install gmake
sudo pkg install llvm38
sudo pkg install pcre2

This will build ponyc and compile helloworld:

gmake
./build/release/ponyc examples/helloworld

Building on FreeBSD

First, install the required dependencies:

• FreeBSD 11 for amd64 (64-bit). It is extremely difficult to coordinate the LLVM version, operating system support for atomics, and Pony to work in harmony on FreeBSD 10 or earlier. (See additional info below that mentions problems with 32-bit executable support.)

• The following packages, with their installation commands:

sudo pkg install gmake
sudo pkg install llvm38
sudo pkg install pcre2
sudo pkg install libunwind

This will build ponyc and compile helloworld:

gmake
./build/release/ponyc examples/helloworld

Building on Mac OS X

You'll need llvm 3.9.1 and the pcre2 library to build Pony. You can use either homebrew or MacPorts to install your dependencies.

There is experimental support for LLVM 4.0.1 or 5.0.0, but this may result in decreased performance or crashes in generated applications.

Installation via homebrew:

brew update
brew install llvm@3.9 pcre2 libressl

Installation via MacPorts:

sudo port install llvm-3.9 pcre2 libressl
sudo port select --set llvm mp-llvm-3.9

Launch the build with make after installing the dependencies:

make
./build/release/ponyc examples/helloworld

Building on Windows

Note: it may also be possible (as tested on build 14372.0 of Windows 10) to build Pony using the Ubuntu 14.04 instructions inside Bash on Ubuntu on Windows.

Building on Windows requires the following:

• Visual Studio 2017 or 2015 (available here) or the Visual C++ Build Tools 2017 or 2015 (available here), and
  • If using Visual Studio 2015, install the Windows 10 SDK (available here).
  • If using Visual Studio 2017 or the Visual C++ Build Tools 2017, install the latest Windows 10 SDK (10.x.x.x) for Desktop from the Visual Studio installer.
• Python (3.6 or 2.7) needs to be in your PATH.

In a command prompt in the ponyc source directory, run the following:

make.bat configure

(You only need to run make.bat configure the first time you build the project.)

make.bat build test

This will automatically perform the following steps:

• Download some pre-built libraries used for building the Pony compiler and standard library.
  • LLVM
  • LibreSSL
  • PCRE
• Build the pony compiler in the build/<config>-<llvm-version> directory.
• Build the unit tests for the compiler and the standard library.
• Run the unit tests.

You can provide the following options to make.bat when running the build or test commands:

• --config debug|release: whether or not to build a debug or release build (release is the default).
• --llvm <version>: the LLVM version to build against (3.9.1 is the default).

Note that you need to provide these options each time you run make.bat; the system will not remember your last choice.

Other commands include clean, which will clean a specified configuration; and distclean, which will wipe out the entire build directory. You will need to run make configure after a distclean.

Building with link-time optimisation (LTO)

Link-time optimizations provide a performance improvement. You should strongly consider turning on LTO if you build ponyc from source. It's off by default as it comes with some caveats:

• If you aren't using clang as your linker, we've seen LTO generate incorrect binaries. It's rare but it can happen. Before turning on LTO you need to be aware that it's possible.

• If you are on MacOS, turning on LTO means that if you upgrade your version of XCode, you will have to rebuild your Pony compiler. You won't be able to link Pony programs if there is a mismatch between the version of XCode used to build the Pony runtime and the version of XCode you currently have installed.

You can enable LTO when building the compiler in release mode. There are slight differences between platforms so you'll need to do a manual setup. LTO is enabled by setting lto to yes in the build command line:

make lto=yes

If the build fails, you have to specify the LTO plugin for your compiler in the LTO_PLUGIN variable. For example:

make LTO_PLUGIN=/usr/lib/LLVMgold.so

Refer to your compiler documentation for the plugin to use in your case.

Building the runtime as an LLVM bitcode file

If you're compiling with Clang, you can build the Pony runtime as an LLVM bitcode file by setting runtime-bitcode to yes in the build command line:

make runtime-bitcode=yes

Then, you can pass the --runtimebc option to ponyc in order to use the bitcode file instead of the static library to link in the runtime:

ponyc --runtimebc

This functionnality boils down to "super LTO" for the runtime. The Pony compiler will have full knowledge of the runtime and will perform advanced interprocedural optimisations between your Pony code and the runtime. If your're looking for maximum performance, you should consider this option. Note that this can result in very long optimisation times.

VirtualBox

Pony binaries can trigger illegal instruction errors under VirtualBox 4.x, for at least the x86_64 platform and possibly others.

Use VirtualBox 5.x to avoid possible problems.

You can learn more about AVX2 support.

Building Pony on Non-x86 platforms

On ARM platforms, the default gcc architecture specification used in the Makefile of native does not work correctly, and can even result in the gcc compiler crashing. You will have to override the compiler architecture specification on the make command line. For example, on a RaspberryPi2 you would say:

make arch=armv7

To get a complete list of acceptable architecture names, use the gcc command:

gcc -march=none

This will result in an error message plus a listing off all architecture types acceptable on your platform.