ponyc, the Pony compiler: a pre-1.0 actor language with a strict platform matrix

Pre-1.0 means breaking changes arrive on a semi-regular schedule

Pony describes its own status plainly: it is pre-1.0, and the project semi-regularly introduces breaking changes. The maintainers add that these changes are usually fairly easy to adapt to, and that applications written in Pony are currently used in production environments. Both statements matter at once. You can ship Pony, and you should also expect to touch your code when the compiler moves.

The release cadence shows what that looks like in practice. Version 0.77.0 was tagged on 17 October 2026, 0.77.1 on 22 October and 0.77.2 on 28 October. Three tags in about eleven days is a fast rhythm for a compiler. The repository itself saw a push on 2 November 2026 and is not archived.

The consequence is that a Pony project needs a pinned compiler version, and upgrading is a task you plan for rather than a background chore. The version string sits in a top-level `VERSION` file, and the repository keeps a `CHANGELOG.md` and a `.release-notes/` folder, which are the places to read before moving from one 0.x release to the next.

Four support tiers decide whether you get a binary or a build job

The platform table is the most concrete part of the project's documentation, and it uses four labels. Released means official prebuilt binaries, also tested in CI. Tested means it is tested in CI but you build from source, because no prebuilt binary exists. Best-effort means the combination is not in CI; it is built from source and tested periodically on real hardware. Unsupported means no support at all.

Read the rows with that legend in hand. Linux on amd64 and arm64 is Released, and so are macOS and Windows on both amd64 and arm64. Linux on riscv64 is Tested. Linux on arm32 is Best-effort, so a regression there could sit unnoticed until someone runs the tests on hardware.

The practical difference between Released and Tested is a toolchain on your machine. If you work on a Tested platform you must compile ponyc yourself before you can compile any Pony.

The BSDs are tested, but FreeBSD and OpenBSD on arm64 are out

FreeBSD on amd64, OpenBSD on amd64 and DragonFly BSD on amd64 are all marked Tested. They run in CI, and there are no prebuilt binaries for them, so each is a build-from-source install.

The arm64 column is blunter. FreeBSD arm64 and OpenBSD arm64 are both marked Unsupported, meaning no support, not merely no binary. DragonFly BSD has no entry for arm64 or any other CPU beyond amd64, and the table marks those combinations as not applicable because they do not exist.

If your fleet mixes amd64 and arm64 BSD machines, the amd64 hosts can run Pony and the arm64 ones cannot be counted on. There is no workaround in the project's platform notes, so the realistic choices are to keep Pony on the amd64 hosts or move the arm64 workload to Linux, where arm64 is Released.

Windows binaries refuse to run below build 20348

The Windows minimum is Windows 11 or Windows Server 2022, specifically build 20348. The reason given is that Pony's networking uses an OS readiness API introduced in that build. The failure mode is spelled out: earlier versions, including Windows 10, are unsupported, and a Pony binary will not run on them.

Note what that covers. It is not only the compiler. Any program you compile with ponyc and ship to a Windows 10 machine will fail there, so the floor is a deployment constraint on your users, not just on your build machine.

Both amd64 and arm64 on Windows are in the Released tier, so a prebuilt compiler exists. A fleet still on Windows 10 has no route to Pony programs on those machines, and moving the target hosts to Windows 11 or Server 2022 is the only fix the project's notes allow.

Linux needs kernel 5.3 because process exit is detected with pidfd_open

On Linux the minimum is kernel 5.3. Pony's process support detects a child's exit with `pidfd_open`, a system call added in that kernel release. On an older kernel, starting a process returns an error, and earlier kernels are declared unsupported.

This is a narrower failure than the Windows one. The program does not necessarily refuse to start; the error appears when your code launches a child process through the standard library. A service that never spawns subprocesses may seem fine on an old kernel while a batch tool that shells out breaks the first time it does so.

The check to run before adopting Pony on a long-lived Linux host is the kernel version. Enterprise images and containers on shared hosts can report a kernel older than 5.3 even when the distribution looks recent, because a container uses the host's kernel.

Building from source fails at configure time without an SSL library

The standard library's `net` package needs an SSL/TLS development library when you build the compiler. Supported choices are OpenSSL in the 1.1.x, 3.0.x or 4.0.x lines, or LibreSSL. CMake detects whichever version is installed and passes the correct flag to ponyc.

If none is found, the build stops at configure time rather than producing a compiler without networking. That is a clear failure, and it means a minimal build container needs the development headers package, not just the runtime library. Package names differ per distribution and are listed in `BUILD.md`.

This requirement applies to everyone on a Tested or Best-effort platform, since they must build. Users of Released binaries skip it. The project also ships `INSTALL.md` for installation, `INSTALL_DOCKER.md` for Docker images and `EDITORS.md` for editor support, so a Docker image is another way to avoid a local build.

What the repository contains beyond the compiler

Pony is described as object-oriented, actor-model, capabilities-secure and high-performance, and the repository layout reflects a language that ships its own ecosystem. There are `packages/` and `lib/` directories alongside `src/`, a `pony.g` grammar file, a `benchmarks/` folder and `SYSTEMATIC_TESTING.md`, which suggests a dedicated testing approach for the runtime.

The `examples/` tree is organised by topic: actors, C FFI, crypto, data formats, getting started, io, language features, networking, testing and tracing. If you are evaluating the language, the actors and language-features folders are the fastest way to see its model in code, and the c-ffi folder shows how it reaches existing C libraries.

One limit applies to comparisons. People search for Pony against Rust, but the project's own documentation offers no side-by-side numbers, so any claim about relative speed or safety is something you would need to measure on your own workload. There is also an online playground, listed among the project's resources, for trying code without installing anything.

Editorial conclusion

Pick ponyc if you want an actor-model, capabilities-secure language and can live with a pre-1.0 compiler that changes under you; skip it if you are pinned to Windows 10, a kernel older than 5.3, or a CPU and OS pair outside the Released tier and you need a prebuilt binary. Check your platform row before you check anything else.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes