Design phase · GPL-3.0
One language for native apps on every platform.
Elp is an open-source programming language in design. Inspired by SwiftUI and Jetpack Compose, it aims to compile one codebase to native apps for iOS, Android, macOS, Windows and Linux, and to HTML, CSS and JavaScript for the web.

A first look
import { println } from "elp/stdio"
fn main {
println("hello world")
}import { App, Window } from "elp/app"
import { Column, Row, Text } from "elp/app/components"
@App
export fn HelloWorld -> App {
App {
Window {
Column {
Row {
Text("Hello World")
}
}
}
}
}The syntax is still being designed, so these will change. The app version describes its UI as nested components; the compiler turns it into a native app for each platform you target.
Goals
· 601 · native
Native everywhere
One codebase compiled to a real native binary for iOS, Android, macOS, Windows and Linux, and to HTML, CSS and JavaScript for the web. No web views.
02 · safe
Memory and type safe
Ownership without a garbage collector, errors as values instead of exceptions, and a soundness floor no configuration can turn off.
03 · declarative
UI in the language
Declarative, reactive components in the spirit of SwiftUI and Jetpack Compose, as part of the language rather than a framework on top.
04 · accessible
Accessible by default
The best accessibility standards possible, enforced by the compiler and tooling rather than left to good intentions.
05 · tooled
Batteries included
Package management, testing with coverage, profiling and debugging with LLVM, and supply-chain management, built in.
06 · open
Owned by its community
GPL-licensed, with no corporate owner. Any funding will be public, and the design actively avoids mechanisms that lock anyone in.
Status
Design, not implementation.
There is no compiler yet, on purpose. An early lexer, parser and syntax tree were written in Rust and then removed: a front end built against a design that is still moving is rework, not progress. What exists is the design record, 18 specifications each tested against a corpus of real programs, from an HTTP server and a SQLite binding to a Vulkan triangle and a real-time audio playhead.
Implementation resumes once the design settles. Until then, the most useful thing you can do is read the docs and argue with them.
The design record
· 18Memory and ownership
- Memory model
Ownership with var, const and references, scoped release, Buffer<T>, and how it all lowers to Rust.
- Aliasing
Shared, Confined and Synchronized cells, Copy, Duplicate and Move, and crossing threads safely.
Types
- Generics
Mandatory type arguments, overloading, conditional conformance and variance.
- Interfaces
Method-only, nominal conformance and interface dependencies.
- Dispatch
What an interface in a type position means, and when it is existential or universal.
- Patterns
Destructuring, match, Optional narrowing and the pattern grammar.
Functions and errors
- Functions
The call model, methods and receivers, extension interfaces and C function pointers.
- Operators
Operators as interface methods, precedence, and narrowing through && and ||.
- Error handling
Errors as Either<T, E> values. No exceptions, no catch.
Modules and the standard library
- Modules
Packages, imports, the prelude, the manifest and native library allow-lists.
- Standard library boundary
What is language, what is a privileged library, and what is plain Elp.
- Collections
Hashing, insertion-ordered Map, the iteration protocol and mutating receivers.
- Strings
UTF-8 strings, char as a scalar value, literals, escapes and why s[i] doesn't exist.
UI and metaprogramming
- Reactivity
Components run once, reads subscribe and writes patch.
- Macros
Macros as pure functions run at compile time over the AST.
Tooling and process
- Diagnostics
Noisy by default, filtered by configuration, with a soundness floor that can't be turned off.
- Core language probes
Real programs, from an HTTP server to a Vulkan triangle, that test the design and log its gaps.
- Grammar notes
Intentional gaps, use-site rules and open questions in the grammar.
The Elp book
Coming to this site.
As the design settles, the design record will become the Elp book: a guide to the language and its reference, published here at elplang.org. Until then, the docs on GitHub are the only authority on what the language is.
Questions
· 6What is Elp?
Elp is an open-source programming language in design. It aims to let you write an app once and compile it to native code for iOS, Android, macOS, Windows and Linux, and to HTML, CSS and JavaScript for the web.
Can I use Elp yet?
Not yet. Elp is in a design phase and there is no compiler. An early Rust lexer and parser were removed on purpose, because building a compiler against a design that is still changing is rework. Implementation resumes once the design settles.
What does the name mean?
Elp started as Ellipsis. It became 'elp, which is English slang for “help”.
How is Elp different from Flutter or React Native?
Elp aims to compile to a native binary for each platform, instead of drawing its own UI or running JavaScript over a bridge. Its UI model is designed as part of the language, not a framework added on top.
Who makes Elp?
Elp is designed by Dave Mackintosh and sponsored by New World Code Ltd, a UK software company. It is licensed under the GPL-3.0 and is intended to stay community-owned.
How can I get involved?
Read the design docs on GitHub, then open an issue or a pull request. Design discussion is the most useful contribution right now.
Help shape the language.
Fork it, read it, improve it and send a pull request.