We need your help to make Plume better

The Plume Programming Language

Plume is a programming language that aims to be as simple as existing languages like Python. It has a great learning curve, permitting users either to perform simple tasks or to accomplish large projects. Its syntax has been designed to be non-aggressive and free, without sacrificing performance.

fn welcome(name: str): unit {
  println("Hello, " + name + "!")

  return unit
}

welcome("world")
Simplicity

Because simplicity, elegance, and readability should be the norm in programming languages nowadays.

Performance

Interpreted languages shouldn't always mean bad performance: Plume aims at being fast and efficient.

Flexibility

Plume is designed to be flexible and to adapt to the user's needs, not the other way around.

Interoperability

Great interoperability enables great native softwares. Plume's dynamic library support is designed to be easy to use.

Extension driven development

As Plume needs to be flexible, it is designed to be easily extended, by enabling function overloading with type extensions.

Type safety

The language itself and its standard library are designed to be type safe, avoiding any runtime errors from them.

Plume is a programming language that aims to be as simple as existing languages like Python. It has a great learning curve, permitting users either to perform simple tasks or to accomplish large projects. Its syntax has been designed to be non-aggressive and free, without sacrificing performance.

Type safety as a priority

Because runtime errors shouldn't be a thing nowadays. Plume is designed to trap every possible error at compile time, permitting the user to focus on the logic of the program.

The standard library is also fully safe, no function will ever throw a runtime error. It has a little cost obviously, especially in terms of codebase-size, but it's worth it.

list = [1, 2, 3, 4]

// Will print Some(1)
println(list[0])

// Will print None
println(list[98])

Extension driven development

Why should you use even more longer names for functions that are doing philosophically the same thing? Plume is designed to be easily extended, by enabling function overloading with type extensions.

Type extensions come with three key features:

  • Interfaces, which are a way to describe generic behavior for a type by defining a set of methods that the following type must implement.
  • Type extensions, which let the user implement these interfaces for existing types.
  • Generic extension, which enables the user to define functions with generic behavior, for instance (+) for any type that implements numeric interface.
interface show<A> {
  fn show(x: A): str
}

extend show<str> {
  fn show(x) => "\"" + x + "\""
}

fn log<A extends show>(x: A) =>
  println(x.show())

Custom user-defined types

What's a language without the ability to express your own data-structures? Plume permits you to define your own types thanks to ADTs (resp. Algebraic Data Types).

ADT is a complex name for a simple concept: an ADT express a type that can be one of several "functions" (resp. ADT constructors) where each function can have a variable number of types.

type LinkedList<A> {
  Empty,
  Cons(A, LinkedList<A>)
}

xs = Cons(1, Cons(2, Cons(3, Empty)))
// Slightly equivalent to:
// xs = [1, 2, 3]
A project manager

The Plume Project Manager, formally called ppm, is a tool that will help you manage your Plume projects. It will be able to create new projects, build them, and run them. And also providing a way to manage dependencies, and even native libraries.

A bootstrapped compiler

The Plume compiler is currently written in Haskell. This is a great languages for compilers but it is really heavy to install and heavy to build. So, we plan to rewrite the compiler in Plume itself, to make it easier to install, to build, and to maintain.

Used-defined compiler extensions

As Plume is designed to be easily extended, we plan to enable the user to define its own compiler extensions. Like actual user-defined types, these extensions will be defined in the language itself, and will be compiled by the bootstrapped compiler. This should enable the user to define its own syntax, extend the typechecker, and even the code generator.

Complete standard library

Current standard library is quite minimal, and we plan to extend it with more functions, more types, and more modules. We also plan to add more documentation to it, to make it easier to use. This could be combined with the project manager to provide a way to install new standard modules.

And even more features in the future! If you want to know more about the project, please check out our milestones.