Peon is a modern, multi-paradigm, async-first programming language with a focus on correctness and speed
Go to file
Mattia Giambirtone c1a2c9bc55
Updates to README. Cleanup & refactoring
2023-10-01 13:16:40 +02:00
docs Fixed various bugs related to lambdas and imports. Added module info section to bytecode dumps 2023-05-22 12:57:38 +02:00
src Updates to README. Cleanup & refactoring 2023-10-01 13:16:40 +02:00
tests Updates to README. Cleanup & refactoring 2023-10-01 13:16:40 +02:00
.gitignore Updated .gitignore 2022-07-09 13:37:51 +02:00
LICENSE Initial commit from JAPL with some changes 2022-04-04 12:29:23 +02:00 Updates to README. Cleanup & refactoring 2023-10-01 13:16:40 +02:00
nim.cfg Updated nim.cfg with more general import search path 2023-01-24 12:25:01 +01:00 Updates to README. Cleanup & refactoring 2023-10-01 13:16:40 +02:00

The peon programming language

Peon is a modern, multi-paradigm, async-first programming language with a focus on correctness and speed.

Go to the Manual


Peon is currently in the process of being rewritten, but the current design just doesn't allow for that. Hence, a new repository has been created, to start from a blank slate and take what I learned from Peon 0.1.x and make it significantly better

What's peon?

Note: For simplicity reasons, the verbs in this section refer to the present even though part of what's described here is not implemented yet.

Peon is a multi-paradigm, statically-typed programming language inspired by C, Nim, Python, Rust and C++: it supports modern, high-level features such as automatic type inference, parametrically polymorphic generic types, pure functions, closures, interfaces, single inheritance, reference types, templates, coroutines, raw pointers and exceptions.

The memory management model is rather simple: a Mark and Sweep garbage collector is employed to reclaim unused memory, although more garbage collection strategies (such as generational GC or deferred reference counting) are planned to be added in the future.

Peon features a native cooperative concurrency model designed to take advantage of the inherent waiting of typical I/O workloads, without the use of more than one OS thread (wherever possible), allowing for much greater efficiency and a smaller memory footprint. The asynchronous model used forces developers to write code that is both easy to reason about, thanks to the Structured concurrency model that is core to peon's async event loop implementation, and works as expected every time (without dropping signals, exceptions, or task return values).

Other notable features are the ability to define (and overload) custom operators with ease by implementing them as language-level functions, Universal function call syntax, Name stropping and named scopes.

In peon, all objects are first-class (this includes functions, iterators, closures and coroutines).


Disclaimer 1: The project is still in its very early days: lots of stuff is not implemented, a work in progress or otherwise outright broken. Feel free to report bugs!

Disclaimer 2: Currently, the std module has to be always imported explicitly for even the most basic snippets to work. This is because intrinsic types and builtin operators are defined within it: if it is not imported, peon won't even know how to parse 2 + 2 (and even if it could, it would have no idea what the type of the expression would be). You can have a look at the peon standard library to see how the builtins are defined (be aware that they heavily rely on compiler black magic to work) and can even provide your own implementation if you're so inclined.


In no particular order, here's a list of stuff that's done/to do (might be incomplete/out of date):

  • User-defined types
  • Function calls
  • Control flow (if-then-else, switch)
  • Looping (while)
  • Iteration (foreach)
  • Type conversions
  • Type casting
  • Intrinsics
  • Type unions
  • Functions
  • Closures
  • Managed references
  • Unmanaged references
  • Named scopes/blocks
  • Inheritance
  • Interfaces
  • Generics
  • Automatic types
  • Iterators/Generators
  • Coroutines
  • Pragmas
  • Attribute resolution
  • Universal Function Call Syntax
  • Import system
  • Exceptions
  • Templates (not like C++ templates)
  • Optimizations (constant folding, branch and dead code elimination, inlining)

Feature wishlist

Here's a random list of high-level features I would like peon to have and that I think are kinda neat (some may have been implemented alredady):

  • Reference types are not nullable by default (must use #pragma[nullable])
  • The commutative pragma, which allows to define just one implementation of an operator and have it become commutative
  • Easy C/Nim interop via FFI
  • C/C++ backend
  • Nim backend
  • Structured concurrency (must-have!)
  • Simple OOP (with multiple dispatch!)
  • RTTI, with methods that dispatch at runtime based on the true (aka runtime) type of a value
  • Limited compile-time evaluation (embed the Peon VM in the C/C++/Nim backend and use that to execute peon code at compile time)

The name

The name for peon comes from Productive2's genius cute brain, and is a result of shortening the name of the fastest animal on earth: the Peregrine Falcon. I guess I wanted this to mean peon will be blazing fast (I certainly hope so!)

Peon needs you.

No, but really. I need help. This project is huge and (IMHO) awesome, but there's a lot of non-trivial work to do and doing it with other people is just plain more fun and rewarding. If you want to get involved, definitely try contacting me or open an issue/PR!


  • Araq, for creating the amazing language that is Nim (as well as all of its contributors!)
  • Guido Van Rossum, aka the chad who created Python and its awesome community and resources
  • The Nim community and contributors, for making Nim what it is today
  • Bob Nystrom, for his amazing book that inspired me and taught me how to actually make a programming language (kinda, I'm still very dumb)
  • Njsmith, for his awesome articles on structured concurrency
  • All the amazing people in the r/ProgrammingLanguages subreddit and its Discord server
  • Art <3
  • Everyone to listened (and still listens to) me ramble about compilers, programming languages and the likes (and for giving me ideas and testing peon!)
  • ... More? (I'd thank the contributors but it's just me :P)
  • Me! I guess

Ok, cool, how do I use it?

Great question! If this README somehow didn't turn you away already (thanks, by the way), then you may want to try peon out for yourself. Fortunately, the process is quite straightforward:

  • First, you're gonna have to install Nim, the language peon is written in. I highly recommend using choosenim to manage your Nim installations as it makes switching between them and updating them a breeze
  • Then, clone this repository and compile peon in release mode with nim c -d:release --passC:"-flto" -o:peon src/main, which should producepeon binary ready for you to play with (if your C toolchain doesn't support LTO then you can just omit the --passC option, although that would be pretty weird for a modern linker)
  • If you want to move the executable to a different directory (say, into your PATH), you should copy peon's standard library (found in /src/peon/stdlib) into a known folder, edit the moduleLookupPaths variable inside src/config.nim by adding said folder to it so that the peon compiler knows where to find modules when you import std; and then recompile peon. Hopefully I will automate this soon, but as of right now the work is all manual

Note: On Linux, peon will also look into ~/.local/peon/stdlib by default, so you can just create the ~/.local/peon folder and copy src/peon/stdlib there