Luna is a developer’s whiteboard on steroids. Design, prototype, develop and refactor any application simply by connecting visual elements together. Collaborate with co-workers, interactively fine tune parameters, inspect the results and visually profile the performance in real-time.

Traditional software development is broken by design

Software design always starts with a whiteboard. We sketch all necessary components and connect them to visualize dependencies. Such component diagram is an exceptionally efficient foundation for collaboration, while providing clear view over the system architecture and effectively bridging the gap between technical and non-technical team members.

Unfortunately, it is impossible to execute the diagram itself, therefore the logic has to be implemented as a code. The traditional development involves writing thousands of lines of code scattered over hundreds of files, which makes the flow of data unclear and the application architecture hard to understand and extend. While there are many tools addressing the subsequent issues, such as UML architecture diagrams, they do not work well as they deal with symptoms, not the source of the problem. The diagrams tend to quickly become obsolete and they need to be manually updated, so that their consistency is hard to maintain. On the other hand, a pen and a whiteboard are still the most efficient way to design a software.

Dual syntax representation

Luna is the world’s first programming language featuring two exchangeable representations: textual and visual, which you can freely switch at any time. It lets you keep your own coding habits, while giving all the advantages of graphical whiteboard-like interface.

Visual graphs

The visual representation redefines the workflow ergonomy, drastically shortening the time needed for software development.

The visual representation reveals incredible amounts of invaluable information about the structure, behaviour and the flow of the data in the program. It allows for capturing big picture on any stage of a workflow, makes the navigation much easier, enables fast and interactive development and profiling. Detailed performance analysis and real-time visualisation of results enable rapid prototyping. All these advantages can be beneficial for both technical and non-technical people.

Textual code

Luna provides a concise and expressive textual syntax that is elegant yet natural to read and write. It comes equipped with full power of purely functional programming style.

Unparalleled development collaboration

Collaboration is a natural property of software engineering involving many individuals working in a team: developers, architects, business analysts, graphic designers and operations people. Luna bridges the gap between collaborators of different professions. It allows to deliver production-ready software, yet it is easy enough to be used by non-technical team members. It opens up an entire universe of undiscovered ways of collaboration.

Visual profiling

Visual profiling is the most efficient way to inspect and understand all the performance bottlenecks of your application. After enabling the debugging mode, Luna gathers detailed evaluation statistics including computation time, CPU / GPU memory allocation, network transfer and threading model. It can be visualised and interactively inspected using the Nodelab environment.

Category Oriented Programming

Although Luna provides notion of objects, it is not an Object Oriented language. Luna is a Category Oriented language instead.

Category Oriented Programming is a relatively new programming paradigm, developed as a result of our research on modern functional programming. You can think of it as a generalization of Object Oriented Programming mixed with purely Functional one in a world of dependent types. It combines the incredible type safety known from purely functional languages with widely approved convenience to model the world in terms of communicating objects.

After releasing public Luna alpha version we will also publish a detailed article regarding the Category Oriented Programming paradigm.

Cutting-edge design & built-in safety

Luna is a general purpose, purely functional programming language incorporating many recent innovations in programming language design, including:

  • Higher-order functions
    Incrementing every element of random generated list, while passing both random as well as + functions as arguments:

    print [0..100] . each @random . each (+ 1)
  • Non-strict semantics and laziness
    Computing every possible prime number and printing the first hundred to the screen:

    def filterPrime [p|ps]:
        p | filterPrime [x for x in ps if x.mod p != 0]
      allPrimes = filterPrime [2..]
      print allPrimes.take 100
  • User-defined algebraic datatypes
    Implementation of Bool type within Luna standard library:

    class Bool:
  • Structural pattern matching
    Creating a Point object definition, its instance and reading its values using pattern matching mechanism:

    class Point:
        x y z :: Int
      origin      = Point 0 0 0
      Point x y _ = origin
      print 'Origin XY coords are ($x,$y)'
  • List comprehensions
    Removing from list all words starting with underscore:

    print [s for s in lst if s.head != '_']

  • Monadic I/O system
    The Luna's type checker and inferencer understand which functions are I/O actions and which are pure:

    def myTestFunction x:
        print x + 1
    >> typeOf myTestFunction
    myTestFunction :: Num -> Num in IO
  • Data-flow error handling
    Reading user's age from a file and asking about it when an I/O error occured:

    fileAge = open 'age.txt' . to Int
    age     = fileAge.catch e:
         print 'An error occured: ' + e
         read 'Provide your age: ' . to Int
  • Strong dependent type system
    Luna will accept the following code:

    lst = [1,2,3]
    print lst.head

    But will reject the following one, cause it cannot guarantee it will not fail at runtime (unless you enable compiler option --types.partial.allow):

    lst = [0..random]
    print lst.head

Do you want to learn more?


Luna is a great environment for programming language polyglots. Foreign language interoperability is just as easy as creating new foreign node and pasting any Haskell or Python code inside. You can of course use foreign clause in the textual representation as well. Wide range of libraries are ready for an instant use with ease. Interoperability with C++ and JavaScript is in our schedule. Stay tuned!

Please keep in mind that unlike Luna, other programming languages are not designed with visual representation in mind and their source code cannot be expanded to a graph representation.

Unmatched performance and safety

  • Automatic parallelism

Luna is able to automatically partition a program and schedule its execution over every available CPU core in order to shorten the computation time as much as possible.

  • Aggresive compile-time optimization

The final performance of a program depends largely on optimizations performed by the compiler, but not every language can be optimized the same way. Luna and its type system were designed to deliver all the necessary information to allow drastic compile-time optimization.

  • Light threading model

Luna facilitates running millions of threads in a fraction of second due to its light-weight thread model, which schedules logical threads onto available thread pool provided by the operating system.

  • Software transactional memory

The primary concurrency control mechanism which Luna uses is similar to database transactions but it works for shared memory. It is a better alternative to semaphore based synchronization, because it is safer and allows better composability.

Support for software transactional memory is an ongoing work which will be released as a library.

State of the art Open Source compiler and interpreter

Luna ships with a state of the art compiler and an interactive interpreter written entirely in Haskell and Luna itself. The compiler produces either fast machine code native for Linux, OS X or Windows, or JavaScript targeting the web.

We will release the compiler as an open-source project as fast as Luna hits the public beta version.

Join us and get access to private alpha

Fill the form below and we will contact you. You can provide just your email address, but we would choose the first group of alpha-collaborators among those, who provide the details.


Drop us a line at

Subscribe to our newsletter

Copyright © New Byte Order 2016