If you’ve worked with concurrent programming, you know the headaches that come with data races and deadlocks. Pony was created to address these exact problems. But if you’ve looked for Pony’s support policy, you might have been surprised – it doesn’t follow the traditional “LTS for X years” or “EOL on Y date” approach that most languages use.

Let’s explore Pony’s unique support policy and version management approach.

1. What is Pony Language?

Pony is an open-source programming language created by Sylvan Clebsch during his PhD at Imperial College London. The story behind its creation is interesting – he was frustrated by the lack of high-performance languages that could safely handle concurrent code.

Key Features of Pony

Pony provides actor-model-based concurrency and uses a unique Reference Capabilities system that completely prevents data races at compile time. Simply put, if your program compiles, you don’t need to worry about concurrency bugs.

Core Features:

• Type Safety: Mathematically proven type system
• Memory Safety: No concept of null at all
• Concurrency Safety: Data race prevention at compile time
• Lock-Free: No need for traditional synchronization mechanisms like locks or mutexes
• Native Code: High performance through AOT (Ahead-of-Time) compilation

Each actor’s heap is garbage collected independently and concurrently, eliminating the need for “Stop the World” global garbage collection. This is a significant advantage for systems where real-time performance matters.

2. License Policy – Free to Use

Pony uses the BSD-2-Clause license. This is a very permissive open-source license with almost no restrictions on commercial use. You only need to maintain the original copyright notice when redistributing modified source code.

BSD-2-Clause Benefits:

• Commercial use allowed
• No obligation to release source code
• Freedom to modify and redistribute
• Much less restrictive than GPL

Official license information is available in the LICENSE file in the GitHub repository.

3. No Traditional LTS/EOL? Pony’s Unique Approach

This is the most important part. Pony is still in pre-1.0 status and regularly introduces breaking changes. Unlike mature languages that promise “5 years of LTS support” or “EOL in 2027,” Pony doesn’t follow traditional versioning policies.

So How Does Pony Handle Support?

Pony uses a Platform-based Support Policy. Instead of setting support periods for specific Pony versions, they provide builds for each OS platform until that platform’s security update period ends.

4. Platform Support Policy and End Dates (As of November 2025)

Currently Fully Supported Platforms

Based on the latest release information, the following platforms are officially supported:

Recently Discontinued Platforms (Moved to Best Effort)

What “Best Effort” Means

Best Effort platforms have support code in the codebase but don’t receive testing or pre-built binaries. You can build from source, but the Pony team doesn’t officially test or support them.

Current Best Effort Platforms:

• DragonFlyBSD (x86 only)
• FreeBSD (all, after 0.55.x)
• Windows 10 (x86 only)
• Ubuntu 20.04 (after 0.60.0)
• Ubuntu 18.04 (after 0.55.0)
• Fedora 39 (after 2025)
• Fedora 41 (after October 2025)

5. Complete Version History – 2016 to Present

Pony is currently in the 0.60 series. Here’s a comprehensive timeline from the initial public releases in 2016 through 2025.

Major Version Timeline

Detailed 2024-2025 Releases

6. Critical Security Update History

Security patches you must know about when using Pony:

Version 0.58.10 is particularly critical. This version fixed a serious issue where Pony’s core guarantee of preventing data races could be violated, so immediate updates were recommended for all users.

7. LLVM Version Support Policy

Since Pony uses LLVM as its backend, LLVM version support is important:

8. Breaking Changes Policy

As a pre-1.0 language, Pony regularly introduces breaking changes, but these changes are usually fairly easy to adapt to.

Breaking Changes Response Strategy

9. Docker Image Support Policy Changes

Currently Available Docker Images (As of November 2025)

Since October 2025, multiplatform (amd64, arm64) Docker images are available:

Discontinued Docker Images

10. Installation and Version Management – Ponyup

The Pony ecosystem provides an official version management tool called ponyup.

Installing Ponyup

Linux/macOS:

sh -c "$(curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/ponylang/ponyup/latest-release/ponyup-init.sh)"

Windows: See the official installation guide.

Version Management Commands

# Install latest release
ponyup update ponyc release

# Install specific version
ponyup update ponyc 0.60.4

# Install nightly build
ponyup update ponyc nightly

# Check installed version
ponyc --version

11. Production Environment Considerations

Applications written in Pony are currently used in production environments. However, the pre-1.0 status should be considered.

Production Checklist

12. When is 1.0? Future Roadmap

The Pony team is working toward a 1.0 release, but no specific timeline has been announced.

Expected Changes After 1.0

• API stability guarantees
• Clear LTS/EOL policy
• Minimized breaking changes
• Possible long-term support (LTS) versions

Check the latest roadmap at Official GitHub Issues and RFC Repository.

13. Official Resources and Community

Official Resources

Community and Support

Conclusion

Pony uses a unique platform-based support policy instead of traditional LTS/EOL approaches. While the pre-1.0 status means rapid changes, the strong guarantees around concurrency safety and high performance make it compelling.

Key Takeaways:

• Version Policy: Follows platform security support periods instead of traditional EOL
• Current Latest: 0.60.4 (October 31, 2025)
• Platform Support: Alpine 3.20-3.22, Ubuntu 22.04/24.04, Windows 11, macOS
• Major Changes: Ubuntu 20.04 dropped, Alpine-only Docker, expanded arm64 support
• Security: 0.58.10 soundness issue – immediate update required

If you’re dealing with complex concurrency problems, Pony’s unique approach might be the solution you need. However, carefully evaluate your team’s capabilities and project requirements before production adoption.

Keep track of platform support periods and regularly check release notes for safe Pony usage. 🙂