Meta uses the best of computing science, in a different balance than other computer languages. This leads to an exceptionally expressive language that is easier to learn for beginning and occasional programmers, and a powerful, productive tool in the hands of advanced developers. Meta has broad platform support. It is highly efficient and blazingly fast, reducing waste by reducing accidental complexity, leaving only the essential complexity. Meta makes better use of your brain power and your hardware by reducing waste in the software.
"Those who say it cannot be done should not interrupt those who are doing it."
So far, compilers for web browsers and for multiple PC platforms, and a cross compiler producing Atari 8-bit programs have been released. Stay tuned for more!
The easiest way to use Meta is from your web browser. We provide an integrated web console application from which you can edit and run your programs.
If you want to use your local files and tools, or you want to program for systems that don't have a web browser, or you want to use features or performance that are not available in web browsers, you can use one of the following compilers for native platforms. They are network clients to the same web service that the web console uses. The Meta compiler is a combination of toolchains that is complex to install and maintain. This way, you don't have to do that on your systems.
When you compile and run a program, it will be opened as a separate web page into a new window or tab. You may need to give your browser permission to open this pop-up.
You can download and modify the web applications that are generated from your programs to fit them into your own web pages.
Note that a web browser environment is deliberately limited, for security. This means that Meta can't support its full feature set in browsers. Also, features can differ between web browsers. You may have to program specifically for web browsers, or for specific browsers. To access extra features of local systems, use the following compilers for native platforms.
These are αcτµαlly pδrταblε εxεcµταblε programs, that identify and adapt themselves to the platform the first time they run. Note that after this, they don't run on the other platforms anymore, so to run them on another platform you have to copy or download them again.
So far, these programs have been tested on Linux, Apple Mac, Windows and WINE. We are interested in reports of success or failure.
These programs are compiled for 64-bit AMD (K8 Venus+, 2005) / Intel (Core+, 2006) processors. If you have a different system, you can still run the programs from the command line as normal if you have QEmu user-mode emulation of AMD/Intel 64-bit installed. On many systems, this can be installed from your system's software manager.
These early versions of Meta need the curl program to be installed on your system. Please make sure it is available to Meta.
To run Meta, open a command-line/terminal window in the folder where you put run.com or compile.com. Or go to that folder from the command line with the cd command:
Then run the Meta programs like this:
This will output further instructions on how to use the programs. Compile or run a Meta program like this:
Security scanners may prevent Meta from running. In that case, you must give the run.com and compile.com programs permission in your scanner. Please consult the documentation of your scanner how to do that.
For Windows, we provide a stripped-down cURL package, in case you don't have it installed yet:
After unpacking, it is easiest to place the files curl.exe and curl-ca-bundle.crt in the same folder as Meta.
To run Meta, open a command-line/terminal window in the folder where you put run.com or compile.com. Or go to that folder from the command line with the cd command:
On the Unix-like systems, you need to make the files executable. You may be able to do this in a graphical user interface, but that depends on your filer program. From the command line, there is a standard command:
chmod +x run.com
We advise to rename run.com and compile.com to just run and compile. Then you can run them from the command line like:
This will output further instructions on how to use the programs. If you get an error message instead, you may need to start Meta like this the first time:
If your system doesn't have the bash command-line shell installed, try this:
After the first time, you can run the programs like normal. This may for example happen if you use ZSh as command-line shell (for example on Apple Mac). This is an issue in ZSh that is fixed in the latest versions.
On many of the Unix-like systems, the curl program will already be available. Otherwise, it can be installed from your system's software manager.
Compile or run a Meta program like this:
You may also make the programs generally available from the command line, so you don't have to include the path to them. Please consult the documentation of your system how to do that. Then you will be able to run them like this:
MacOS prevents Meta from running. You must give the run and compile programs permission in System Preferences/Security & Privacy or by adding them in System Preferences/Security & Privacy/Privacy/Developer Tools:
If you want to try the Atari version of Meta but don't have an Atari, you can get started here:
See especially section 5, how you can get an Atari emulator for another platform.
Please continue with the documentation to learn how to use Meta.
Several of these goals have been achieved, most are in progress.
Most of these features have been partly implemented, and are also still in progress.
Programming languages bridge the gap between humans and the electronics of a computer. The electronics of a modern computer are often referred to as 1's and 0's, corresponding to the states of the electronic switches. This is already a language, a mathematical notation for on and off. Humans, on the other hand, communicate in natural languages. Programming languages are a mix between natural language, usually English, and mathematical notations. The gap is so wide, that many different programming languages have been designed. Meta puts the balance closer to the human than most other programming languages.
Natural languages evolved together with the human brain. Your brain is well suited to process language, so a programming language closer to natural language will make writing and reading software easier, as long as it is still mathematically precise enough for the machine. If you learned an extra natural language later in life, you will know that it is daunting at first, but it becomes natural with practice. The same is true for learning a programming language, but it is easier if it's closer to natural language. If you already know a different programming language, your brain will have to get used to the concept of a programming language using more principles from human language.
Why make the effort to learn a new language? Software development is the process of translating human ideas and goals into instructions that a computer can execute. This is typically done in multiple steps that result in multiple layers of software, each layer a step closer to the machine and larger than the previous layer, because it is more detailed. We describe the design and specification of the software in human language. When the instructions for the machine are closer to the human language specification, fewer steps and layers are needed. You become more productive, and will have a competitive advantage compared to others who don't make the effort and stick with less expressive programming languages. It is also more fun and motivating.
It is known that the number of lines of program text a software developer can write per unit of time is largely independent of the programming language. Therefore, a language that can express more concepts in the same space - while still being readable - will make you more productive. The software will be smaller, less complex and of higher quality. It is known that, other factors being equal, the number of bugs in software is proportional to the number of lines of the program text and related to the complexity of the software. From security engineering, we know that Trusted Computing Bases (TCB) should be kept as small as possible to improve security and safety. The cost of software development and maintenance will be reduced. Because your brain capacity is limited, and there is also a limit to how organisations can stretch this limit by having multiple software developers work together, reducing the size and complexity of the software means that you can take on larger projects than before.
The young field of computing science has been struggling to establish a reliable software engineering discipline comparable to other fields of engineering. This struggle is not over, as any user of computer devices can attest to. Complexity does not equal sophistication. Reducing the complexity of software and its development process to improve its quality, reliability and safety is of general concern for society. The language in which stakeholders communicate should be brought closer together. A human-friendlier language for software, both program code and data, can not only bring the machine closer to the programmer, it can also bring the user who commissions the software closer to the developer. A friendlier specification language will enable more end users to collaborate on formal specifications with the developer, reducing confusion about their needs.
"In anything at all, perfection is finally attained not when there is no longer anything to add, but when there is no longer anything to take away, when a body has been stripped down to its nakedness."
Meta will be especially suitable for Lean Software Development and related modern methodologies. The first principle of this methodology is to eliminate waste, made more precise by the Japanese term Muda: anything that does not add value for the end user. This methodology of improving effectiveness and efficiency and saving costs is regarded as an effective way to increase profitability.
Part of this waste is in the development process, part is in the software itself. Perhaps you are not aware of waste in software. Software is, after all, mostly invisible. It is not outdated software that you throw away, it is in the software that you use every day. Within software, waste usually hides behind abstraction layers, like dust devils under a carpet. The methodology states that in order to remove waste, one should learn to recognise it. One should learn to distinguish essential and accidental complexity. Being invisible does not mean that software waste is harmless. More lines of program code means more bugs. Even if parts of the software are waste to the point of not being used at all by your application, the bugs in them - that you don't see because you don't exercise them - may still be used by attackers of your systems. There are costs in complexity, unreliability, unsafety, user dissatisfaction, job dissatisfaction; loss of performance, scalability and time-to-market; wasted effort, time, space, network bandwidth and energy - which may also seem hidden if one doesn't look or doesn't have a better reference to compare with.
As responsible dwellers on this planet of limited resources, travelers on Spaceship Earth, we do our best to conserve resources and reduce waste. Why would we not extend this to software and its development? We will show how software can be created accordingly, and will develop case studies to investigate and show where the waste is.
Several aspects of the language and the project can be considered meta-aspects. The literal meaning of "meta" is "beyond", "what comes after". Meta will go beyond what other programming languages do, and people using it can and should also expand their thinking beyond what they are used to.
Meta's compiler is currently written in REBOL and small fragments of the runtime are written in the language of the selected back-end, such as C. When Meta becomes more capable, we will rewrite the compiler in Meta itself, and also as much of the runtime as possible. Meta will then be its own meta-language, being described and implemented in itself.
Further, we will bootstrap the infrastructure for the project by writing it in Meta itself as much as possible.
We think the language is important enough to be a goal in itself, but we are also planning and implementing other projects with Meta. The goals of the project transcend the language project, while we need the language to enable and model them.
Meta is for people with an open mind who want to make an effort to improve. You also need to be able to handle the fact that Meta is a work in progress. It's good, but not perfect. Everyone will find in our projects what they are looking for. If you come to them with a preconception that they can't be any good, or that they should be the same as other products, your brain will trick you into interpreting everything we say negatively and you will imagine to have confirmed your preconceptions. On the other hand, if you are curious and of good will and make an effort to understand what we are saying, you will find a lot to enjoy and use. You must be willing to have your thinking changed by Meta.
We aim to transcend a narrow focus on a specific audience. Meta is a project for developers who need power from their language, but also for occasional programmers who don't have the time to juggle many arcane details, and for people who want to learn programming and are looking for an easier language. It's a project for REBOL fans, but we also welcome programmers from other languages who want to expand their horizon. It's a project for Atari and Syllable enthusiasts, but also for all the other platforms. Meta is for fun and for profit. We don't believe in fundamental contradictions between these uses, and we don't want to create artificial limitations. We believe that, when embraced, these uses will reinforce each other.
We make this possible through Meta's unique combination of properties. Its human-friendly focus and high-level properties reduce the cognitive load on your brain. This brings the language within reach of beginning and occasional programmers, but also frees advanced developers to spend their energy on their application logic, instead of babysitting the language.
Meta's low-level properties and raw performance enable it to run on more diverse platforms than many other languages, and allow advanced developers to still babysit the language when they need to.
Now this does require some mutual understanding from everyone involved. We will build an inclusive community, where anyone with good intentions can feel welcome. The project materials will cater to all knowledge levels, so that people can grow through them.
Not everyone is willing to make the effort to learn to understand Meta and the principles it is based on. This is usually not because they are not capable of doing so, but because they are already used to other computer languages based on different principles. Some of them even fiercely resist the notion that Meta could be rational and useful, in spite of the more than half a century of scientific and practical history in related languages that are highly influential on many modern computer languages and systems. To understand why this happens, read these articles:
Meta is outside their bounds of rationality, leading them to rationalisations that are bizarre to those who do understand Meta. While this is unfortunate, it also shows that Meta is a real innovation that pushes these bounds, towards greater rationality. If you want to give it a positive spin, it is also a clear way to outcompete them. We need to focus on those for whom Meta is within their bounded rationality, so they can achieve the results that show others the progress.
An odd consequence of this is that Meta needs a two-pronged approach of focusing on both beginning and advanced programmers. Beginning programmers haven't invested much yet in different languages, so they may as well try Meta. Advanced programmers have the insight to see that Meta solves several pervasive problems in programming, and the mental capacity to learn a different language. Of course, this also makes Meta suitable for medium-level programmers, but that is not in our hands: it depends on their mental agility. One can lead a horse to water, but one can't make it drink.
If you find yourself in the middle group, and you do want to make an effort to learn Meta, but you can't get your head around it, it is very useful to read the following essays. They are about Logo, Lisp and Scheme, but much the same fundamental principles apply to Meta. The second essay explains them in terms of different, popular programming and data languages such as XML, SQL, C and its preprocessor, C++, Java and C#:
In spirit, Meta is a descendant of the REBOL and Logo languages, but with performance close to C. Meta is mostly inspired by REBOL. It is not meant to be compatible with REBOL, but it will eventually be quite close. However, it is not complete yet, and there are many subtle differences to optimise the language and extend its reach.
In theory, REBOL's dialecting lets it adapt to all domains of programming. Unfortunately, there are other factors that put limits on the applicability of the language. While REBOL's expressiveness and minimal redundancy allow it to be tiny compared to many other languages, it is not tiny and efficient enough for cases where performance is critical. Nor is its architecture open enough for systems programming and other cases that demand efficient interfacing with external systems and libraries. This is due to REBOL's monolithic interpreted execution model, which makes it a relatively slow language, and due to its high-level type system, which makes it memory-hungry and does not support the data types of external systems.
Meta is close to REBOL, but solves its weaknesses. It is designed and optimised for compilation. The compiler is currently written in REBOL 3. The architecture is broadly modelled after the design of LLVM, constructed around an Intermediate Representation. The user-facing front-end language is a REBOL dialect. Its type system is a combination of the high-level type system of REBOL and a safe form of the type systems of medium-level languages such as C and Pascal. The back-end architecture was designed around WebAssembly and extended for generating C and native binary machine code. Multiple back-ends can generate and optimise code for a wide range of target platforms and target languages.
Meta has been under full-time development since June 2020, after a period of research and design that spanned several decades. Its name was revealed in August 2021 and it was first released in October of that year.
Is it useful for anything yet? Yes! Meta runs its own project and the others under the Meta Project umbrella. This website, the downloads, the web console and the custom forums are served to you by the language itself. Some example programs have been published. The remote Internet client to compile them is also written in Meta itself.
Compared to REBOL, its predecessor, Meta has REBOL's high-level syntax, but it doesn't yet have its high-level data types and its dynamic features, such as dynamic code generation and execution. These will be implemented over time. On the other hand, Meta far exceeds REBOL's performance, interoperability with other sub-systems, and ability to run on many platforms, including tiny ones.
Is Meta usable for you yet? That depends on your use case and your attitude. Meta is a work in progress that is being developed for its published target and host platforms, use cases and other sample programs. If your platform is supported and your use case is similar to the samples, you will have a good chance of success. Currently, you need to be willing to work around temporary limitations in the language and documentation.
Many of the current limitations can be worked around, and Meta will still reward you with outstanding results. The language is incomplete, but compiled programs are of production quality - unless you need garbage collection of memory for long-running programs.
If you need support, contact us for consulting or contract development.
Climbing over fences of walled gardens
Meta is being developed on 64-bit Linux. In-house we have preliminary test programs written in Meta running on several other platforms and sub-platforms. So far, a compiler for web browsers and multiple PC platforms, and a cross compiler for Atari 8-bit home computers through the C back-end have been released. Stay tuned for more.
The Atari 2600 was one of the first game consoles. It has 128 bytes of RAM and an 8-bit processor running slightly over 1 MHz. It shows that the language is fast enough to "race the beam": to draw the television display scanline by scanline in real-time, hundreds of scanlines 50 to 60 times per second. It proves that Meta can target very small devices, can use native system features, and can run on bare hardware, without an operating system.
The Atari 8-bit was Atari's first personal/home computer system, follow-up to the Atari 2600. It is a complete platform, including an operating system, in a very compact and efficient form. It proves that Meta can achieve a high level of platform abstraction, by running cross-platform programs unchanged on anything from Atari 8-bit to 64-bit PC's.
The C back-ends use a C toolchain for the platform, to be able to target a broad range of platforms. The native back-ends generate machine code directly, without relying on a third-party toolchain, in the executable binary program format for the platform. The native back-ends reduce Muda compared to the C back-ends. They prove that Meta can be more efficient and less wasteful than C, both in the generated programs and the toolchain. On the other hand, the native back-ends require more work per platform for us to implement them, so the cross-platform C back-end is currently the most developed.
Current priorities, in order. There is no time schedule for these developments. Much depends on support from the community and funding by organisations. We can implement specific wishes when there is funding for them. In times when there is no funding, we will follow our own priorities, which usually follow the low-hanging fruit. If you need guarantees on certain features and their planning, contact us for contract work.
The audience chosen for early introduction are the Atari 8-bit and Atari 2600 communities. These small machines are a good start to build on. They are easier to work for than modern platforms due to less complexity, and keep you aware of efficiency: these platforms hardly tolerate Muda. They provide meaningful results earlier: the Minimum Viable Product is smaller for a small platform.
The target platform chosen for the first release was the Atari 8-bit based on the CC65 back-end. This is a small but complete platform that can show all current features of Meta. CC65 is a standards-compliant but relatively basic C implementation, making it a good baseline for the C back-end. Code generated for CC65 is likely to work with most other C compilers and cross-platform C libraries. The Atari community is helping with Meta's development, so we want to show our appreciation.
There will always be a free version of Meta. We will build a business on top of it, by offering paid premium versions and other products built with Meta.
To grow the project, we very much want to release Meta as open source under a permissive licence, eventually. However, a number of criteria need to be met before that is prudent. The current implementation is written in REBOL. Once Meta is capable enough, we will rewrite it in itself. The REBOL version will then no longer be maintained, and open-sourcing a code base without maintaining it is futile. Further, we need to develop premium products to sustain the business model, before we can give away the core products for free. This will be a gradual process. So far, we open-source everything that runs on your local machine: the remote compiler client, the sample programs, the web console client and the forum client web application. As we develop more products, more of the base products can be open-sourced. We will also gradually open up the project to outside contributions, when it makes sense.
We can have nice things, but we need to create them ourselves.
You are welcome to discuss Meta in the forums. Besides our own forums, we also participate on several forums of external communities. We strive to be available there. Please keep the conversations constructive. Developing Meta is a huge task. We do our best to support your use of Meta, but please understand that we don't have time to engage in unproductive discussions.
Meta has been introduced to the cross-platform REBOL community here:
The REBOL community will have an important place in our community, because they have already wrapped their brains around the language principles and can show others who want to learn programming, or who are used to other programming languages, how to make the best use of a language from the REBOL family.
Meta was first introduced to the Atari 8-bit and Atari 2600 communities, on the AtariAge forums. We foresee an important place in our community for the retro-computing communities, as Muda Masters who can inspire others on larger platforms and show how software can be kept close to its essential complexity. The Atari community is providing excellent feedback and development help, including for modern cross-platform concerns. Here are the main discussion threads:
Both forums contain example programs. The Atari 8-bit threads contain a fairly extensive development history and background documentation of Meta.
We will keep targeting the language to more platforms and introducing the project to their communities.
The project and its community can be contacted on its forum.
If you need to contact us privately, you can do so by email: [email protected]. We are available for contract work on or using Meta. We can also arrange guaranteed availability of Meta's source code through escrow, or on-site Meta installations under NDA.