Plutus Integration with Pony Lang

Pony is a performant actor model language with guarantees like Haskell, and memory safety like Rust. Integration for PABs and side-chains.

I've spent 15+ years studying complex systems with a focus on how primitives in language design can simplify the process of building them.

This is the most ambitious of the three proposals I've submitted this round. Part of my motivation is to better understand the core semantics of Plutus, and the other part is to provide a way to use the high performance actor model capabilities of the Pony programming language for applications on the Cardano platform.

My other proposals this round could benefit from this:

https://cardano.ideascale.com/a/dtd/Distributed-Collaboration-Protocol/369937-48088#

https://cardano.ideascale.com/a/dtd/Elm-Integration-with-Plutus/370150-48088

Working on distributed collaboration would benefit from the types of simulations that are made easy with Pony's concurrency model, and the flexibility of Pony's type system. Pony also has lock-free memory safety and object capabilities that can protect different parts of a system from gaining access to functionality they shouldn't have.

The possibility of compiling Elm code to Plutus Core would open the door to tightly coupling frontend code with on-chain code, and integration with a highly scalable backend that's possible with this project.

Timeline:

Three Months: There are different ways to interface Pony with Plutus. My current thought is that writing a Plutus Core interpreter would be the most useful way to do this, but I'm open to suggestions. This would require expressing Plutus Core semantics in terms of the Pony type system, which is what I'd be spending the initial phase of this project working on. This would open the door to running Plutus code in Pony for use as a side chain, or generating Plutus code to be run on the main chain. I'll probably drop the Haskell implementation of the Plutus Core interpreter into my codebase to test against the output of the code I write. It's also possible that I could import the Haskell code as a library into Pony, which would probably be less work, but the current story of how to load Haskell code into a C-style FFI isn't ideal. I'm not sure about loading a Pony module into a Haskell codebase. The first phase of this project is about research and setting an optimal plan in place.

Six Months: At this point, I should be well on my way to producing a library for interfacing Pony and Plutus! All the code and documentation that I write will be open source, and pushed to the git repository attached to this proposal. I'm open to any feedback and help that the community might want to provide.

Twelve Months: Hopefully, there will be a working library that developers can use to add distributed stream processing and actor-based simulations to their Plutus applications... for side chains or off-chain code.

(Depending on the acceptance of my other proposals, timelines would be subject to change, and I reserve the right to interleave work on each project as I see fit. Some of the research I do for the other projects could give direction to this one and vise versa.)

I'm currently living in Malawi, in southeast Africa, and can easily live off of $1000 a month if I need to ($1000 * 6 months). The budget is for six months of work, beyond that, I'll probably just continue working on this project for free, because it will be useful for other things I want to do in the future. I've been living off of my savings in Ada since April and devoting most of my time to studying the Cardano platform and related topics. It would be nice to have an income besides bull runs in the price of Ada, so that I can focus on building free tools.