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.
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.
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.
Read more about Luna principles
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.
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.
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
Piotr Mlodawski
Visual Luna Developer
Marcin Mikolajczyk
Compiler Developer
Sylwia Brodacka
Back-end Developer
Leszek Kania
Visual Luna Developer
Jan Klosowski
UX Designer
Piotr Moczurad
Compiler Developer
