Luna – A WYSIWYG language for data processing

Luna.
A WYSIWYG language for data processing.

You and data. Immediate connection.

Luna is a data processing and visualization environment built on a principle that people need an immediate connection to
what they are building. It provides an ever-growing library of highly tailored, domain specific components and an
extensible framework for building new ones.

Luna targets domains where data processing is the primary focus, such as data science, IoT, bioinformatics, graphic
design and architecture.

Overview

Data flow graph. Immersive.

Luna is also a powerful data flow modeling whiteboard, allowing you to literally draw components and the way data
flows between them.

However, instead of being hard coded, components in Luna are simply nested data flow graphs. You can enter into any
component or into its subcomponents to move seamlessly from high through to low levels of abstraction at will. You
can move all the way down, from a painting canvas to its underlying bitwise operations.

Overview

Powerful engine. Limitless.

Luna was built on a principle that people should not be limited by the tool they use. It was designed as a general purpose
programming language with two equivalent representations – visual and textual. The graphs are as powerful as the
code and Luna lets you switch between them at will.

Visual Luna

WYSIWYG data processing

Luna components visualise their results and use colors to
indicate what type of data they exchange, so you can compare
all the intermediate outcomes and
understand the flow of data just by looking at the graph. You
can also play with parameters and
observe how they affect each step of the computation in real
time. It lets you iterate rapidly,
test a wide range of ideas and deeply understand the domain
you are investigating.

Zoom out and harness the complexity

Every component in Luna is built out of other components. This hierarchical design makes it easy
to gradually change the abstraction level. Zoom out to see data transformations from a higher
perspective. Zoom in to fine tune individual component’s behavior. With a single keystroke, you
can collapse several connected components into a new, more powerful one and share it with
others.

Visual debugging and profiling

Network service outages and data corruption are a part of life but Luna can also assist
analysing these types of problems. When an error occurs, Luna tracks and displays its path
through the graph, so you can easily follow it and understand where it comes from. Moreover,
Luna records and visualizes extensive information about performance and memory consumption
allowing you to discover bottlenecks just by looking at the graph.

Luna explorer, your personal assistant

Luna provides the Explorer, a context-aware fuzzy search engine that lets you rapidly query
libraries for desired components and browse their documentation. The Explorer is context-aware,
so it understands the flow of data, tries to predict your intentions and adjusts the search
results accordingly.

Work at the speed of thought

Luna was designed with a focus on ergonomics and productivity. Visual components are just code
expressions, which Luna analyses and displays an interface for. You can express your thoughts
faster and use many fewer nodes than in competitive solutions. Connecting components is a breeze
with the connection pen and the auto-connection system, while clean and concise design minimizes
distractions, yet provides you with all the information you need, when you need it.

Dual syntax representation

Luna is the world’s first programming language featuring two
equivalent syntax representations, visual and textual. Changing one
instantly affects the other. The
visual representation reveals incredible amounts of invaluable
information and allows capturing the big
picture with ease, while the code is irreplaceable when developing
low-level algorithms.

Textual Luna

Modern purely functional programming

Luna is a general purpose, purely functional
programming language incorporating many
recent innovations in programming language
design, such as
higher-order functions, non-strict
semantics, algebraic data types, object
oriented programming and
sophisticated type inference engine. All
that enclosed in an expressive textual
syntax that is
natural to read and write.

Static typing meets dynamic feel

The type inference engine tracks and
understands
all data transformations. It also resolves
ambiguities without sacrificing the
incredible safety
that purely functional languages are known
for. However, you can write out types if you
choose, or
ask the compiler to write them for you for
handy documentation.

Automatic parallelism

Luna uses the state of the art Haskell’s GHC
runtime system, enabling it to run thousands
of threads in a fraction of a second.
Moreover, Luna
automatically partitions a program and
schedules its execution over available CPU
cores.

Interoperability with other languages

Luna will let you paste any Haskell, C and
JavaScript code into a component, handling
the Interoperability for you. This way you
can use
existing code and libraries with no effort.
However, unlike Luna, other languages were
not designed
with visual representation in mind, so you
will not be able to expand components
defined this way
into a sub-graph representation.

Hi, we are the Luna team!

Founders

Wojciech Daniło CEO

Haskeller, programming languages design freak, open source
enthusiast. Passionate about visual programming, aesthetics
and ergonomics. Former senior R&D
technical director responsible for developing visual effects
tools for A-title Hollywood movies.
One of the early founders of Flowbox.io. Loves dogs, hates
JavaScript.

Marcin KostrzewaCTO

Theoretical Computer Scientist passionate about mathematics,
type theory and programming language design. Believes that
it’s about time to retire the 70’s ways of programming and
embarked on a quest to make that happen. Can’t make it
through the day without a hefty dose of caffeine.