Brick

Brick is a modern, functional, OO-like language, designed to have the expressiveness you've come to expect from languages like Ruby and Python, joined with the power of Common Lisp, Rust, and ML.

Here's a quick list of features we are working on supporting in the core language:

• Classes for organization
• Mixins
• Type Inference/Reconstruction
• Parametric Polymorphism
• Overloading
• Hygenic Macros
• Pattern Matching
• Algebraic Data Types
• Traits
• Parallelism

Here's the obligitory Hello World:

fn main
  puts("Hello, World!")
end

And something a bit more complex:

fn main
  let nums = [1, 2]
      noms = ["Chad", "Nick", "Kristen", "Steve"]
      odds = nums.map(|x| -> x * 2 - 1)
  in
    odds.each => |num|
      puts("%s says hello from a new thread!", noms[num])
    end
  end
end

Interested?

Read the docs

Getting Involved

So you want to help out. That's great!
Whether you're a Ruby developer, a Node.js hipster, or a C wizard, we can use your help.

Here's some areas we're working on right now:

• The language definition (Kind of a big deal to get this ironed out)
• Writing the reference compiler/interpreter. Technologies used include:
  • OCaml
  • Sedlex: The tokenizer
  • Menhir: The program parser
  • LLVM: The backend
  • Linenoise: The REPL
• Writing the runtime for the compiler. Technologies used include:
  • libuv: Cross-platform abstraction
  • C: Glue between all the pieces
• The website, brick-lang.org. Possible technologies include:
  • Node.js + Express
  • Ruby + Jekyll or Sinatra

About Rust and Brick

It's come to my attention that some people see Brick as a clone of Rust. This is not the case.

Brick was imagined as a sister language to Rust. Where highly performant, low-level applications may be written in Rust, Brick is intended as the flip-side of that coin: highly parallel, high-level applications.

C and C++ (and to some extant Go) are used as systems languages, Rust attepts to bring features from languages like OCaml and Haskell to this area.

On the other hand, Clojure, Scala, and OCaml are the main functional languages for application development. Clojure and Scala are tied to the JVM, while OCaml is in need of a serious overhaul of the runtime (no threading).

I want to use features from OCaml and Haskell and Rust in my daily work. But I don't do systems level programming very often. It's too low level for many of the things I do.

So Brick is being designed to integrate with other languages at a low level, such as Rust and C. But it's not a competitor at all. If you debate between using Brick and Rust, you should re-evaluate your intent.

Not to mention that Brick is nowhere near the level development of Rust right now :P