# Meta

## A New, Human-Friendly Programming Language

### Reducing software waste

We have entered a world in which we need to do more with less. If you, like us, have frowned at the difficulty and inefficiency of creating software, and wondered if there is a better way, Meta is for you. It is a descendant of the acclaimed REBOL and Logo computer languages. Logo was designed in academia to teach programming in a simple yet powerful way. It is widely used in education and influenced many newer systems and languages. REBOL extended this concept to professional programming. It was invented by Carl Sassenrath, the chief software designer of the famous Amiga computer, the first consumer multimedia system. Meta takes the next step by combining this design with the virtues of the C programming language, which has been the standard for software interoperability and performance for half a century.

Meta uses the best of computing science, in a different balance than other computer languages. Because of this, it is 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. It also enables us to offer broad platform support. If you would like to be able to program many different environments with the same language or even the same program source code, Meta is for you.

Meta is highly efficient and blazingly fast, because it reduces waste by reducing accidental complexity, leaving only the essential complexity. Because it reduces waste in the software, it makes better use of your brain power and your hardware. We create Meta to free us from software that is needlessly difficult and inefficient. You won't find this combination of human-friendliness, power and performance anywhere else.

"Those who say it cannot be done should not interrupt those who are doing it."

Introducing Meta to the αcτµαlly pδrταblε εxεcµταblε & Cosmopolitan community.

### Get Meta

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!

Most people get started with Meta in their web browser, because it's the easiest way to try it out. 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. Because they are network clients to the same web service that the web console uses, we can offer an easy way to install Meta. The Meta compiler is a combination of toolchains that is complex to install and maintain. This way, we can do that for you, you don't have to do that on your systems.

#### Web Browsers

Web Console

Your web browser needs to support JavaScript. Browsers that are really old may not work, but most browsers should be supported.

When you compile and run a program, it will be opened as a separate web page into a new window or tab. Because of this, 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 because of security, a web browser environment is deliberately limited. Because of this, 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.

#### Windows 8+, WINE 7+, Apple MacOS 15.6+, Linux 2.6.18+, FreeBSD 13+, NetBSD 9.2+, OpenBSD 6.4+

Older platform versions may work depending on the features used in Meta programs. So far, these programs have been tested on Linux, Apple Mac, Windows and WINE. We are interested in reports of success or failure.

• Meta Remote Compiler
This is a command-line program that takes a Meta program text, produces a binary αcτµαlly pδrταblε εxεcµταblε program, and then runs it.
• Meta Remote Cross-Compiler for Atari 8-Bit (400/800/XL/XE)
This is a command-line program that takes a Meta program text and produces a binary Atari 8-bit program.

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.

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.

##### Windows First Use

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:

cd path\to\Meta

Then run the Meta programs like this:

run

This will output further instructions on how to use the programs. Compile or run a Meta program like this:

run example.meta
compile example.meta

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.

After using run, you can run your program again without recompiling, like this:

program
##### Apple Mac, Linux, FreeBSD, NetBSD, OpenBSD First Use

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:

cd path/to/Meta

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:

./run

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:

bash -c './run'

If your system doesn't have the bash command-line shell installed, try this:

sh ./run

After the first time, you can run the programs like normal. This may for example happen if you use ZSh or FiSh as command-line shell (for example on Apple Mac). This is an issue in ZSh and FiSh 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:

./run example.meta
./compile example.meta

After using run, you can run your program again without recompiling, like this:

./program.com

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:

run
##### Linux, Windows Sub-system for Linux (WSL), WINE First Use

If the bash workaround above doesn't work for you and still produces an error when starting Meta programs, further instructions are here:

Getting started with αcτµαlly pδrταblε εxεcµταblε

##### Apple Mac First Use

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:

##### Atari 8-bit (400/800/XL/XE)

If you want to try the Atari version of Meta but don't have an Atari, you can get started here:

Newbies or veterans returning to Atari

See especially section 5, how you can get an Atari emulator for another platform.

### Getting Started

Because Meta is a unique language, you need to study the documentation to learn it.

### Goals

Several of these goals have been achieved, most are in progress.

• Strike a balance between science and practicality: apply good ideas from (computing) science to improve solutions to practical problems.
• Increase programming productivity.
• Improve software quality: its performance, portability, readability, reliability, security and maintainability.
• Reduce cost and risk in developing and running software.
• Enable more people to learn programming.
• Reduce the cognitive load of programming on humans. Enable as much of a system as possible to fit in a single person's head.
• Optimise the design for humans first, then for machines. Make the machine work for the human, instead of the human for the machine. Don't make the human do work that the machine can figure out. Make human-friendly design choices.
• Use the existing power of human language better than most computer languages. Optimise expressiveness and conciseness, while maintaining readability. Specify what you want done, let the language figure out how.
• Simple where it can be, advanced where it needs to be. Different balance of complexity than other computer languages.
• Smooth learning curve from beginners to advanced developers. The language is deep, but it should be possible to teach the basics to children.
• Support constructionist learning.
• Build interactive guidance into the language tools, to reduce the need for separate documentation.
• Minimise software waste, by reducing redundancy and unnecessary work: reducing accidental complexity, leaving only the essential complexity. This goal enables a series of other goals:
• Support the methodology of Lean Software Development.
• Support a wide range of use cases, from systems programming to application development. We believe this can be done in one language if it is capable and flexible enough.
• Support a wide range of platforms. Leave no soul behind. There should be no need to use some other language due to lack of availability.
• Support both cross-platform programs and platform-specific programs.
• Performance matters. Even though modern hardware enables inefficient software to handle many tasks, this comes with extra costs, and whole classes of performance-sensitive tasks remain out of reach. Performance doesn't matter until it does - and that can be suddenly during a project. Looking forward, Moore's law is running into its limits. Computer languages must be fast again to be competitive. There should be no need to use some other language because of performance.
• Fast compilation times. Little waste of developer time.
• Fast startup and execution times. Little waste of user time.
• Produce small to tiny executable files. Little waste of storage space, memory, network bandwidth and startup time.
• Build the language on itself, multiplying its strength and reducing redundancy.
• Build the project on the language itself, multiplying its strength. The proof of the pudding is in the eating.
• Build the language and the project incrementally, to conquer the dragon of their complexity. A journey of a thousand miles starts with taking the first step. The project will develop over many years; it is too big to do it in one go.
• Release early, release often, to gather and incorporate feedback. The perfect is the enemy of the good.
• Support actual use cases. Make the language usable for specific cases as soon as possible, for ourselves and others.
• Support both open-source and closed, commercial software. You don't have to ship your source code with compiled programs.
• Integrate well with existing systems. No language is an island.
• Make use of existing sub-systems when this enables quick progress. Stand on the shoulders of giants.
• One of the giants on whose shoulders we stand is the REBOL language. Bootstrap Meta off of REBOL by writing the first version in REBOL 3 and making use of REBOL's documentation, available program code, and support in tools such as text editors, as much as possible without compromising Meta's design.
• However, limit dependencies, especially when these cause single points of failure. Don't stand on the shoulders of dwarves. Don't stand on the shoulders of angry giants. Don't stand on the shoulders of stupid giants. Don't stand on the shoulders of giants with attention deficit disorder.
• Pick the low-hanging fruit in features and use cases, to make quick progress. Building the language on itself, this will usually bring the next rung of fruits within reach.
• Everyone who uses the project should contribute something to it, in some way that suits them.
• Sustain the project on a freemium model: a mix of crowd-funding, free and paid products and support services such as consulting and contract development.
• Gradually open-source the base products, once the funding allows it. So far, we open-source everything that runs on your local machine.
• Have fun creating Meta. It's a huge task, so we need to keep ourselves motivated to accomplish it.
• Build an inclusive community, where anyone with good intentions can feel welcome, to help us achieve it.

### Features

Most of these features have been partly implemented, and are also still in progress.

• General-purpose language. Special purposes can be supported by creating Domain-Specific Language dialects.
• Right-level language: high-level where it can be, low-level where it needs to be. One size does not fit all.
• The language adapts to the platform to support a wide range of systems. The language strongly supports to write cross-platform programs, but also has strong support for writing platform-specific programs.
• Human-friendly syntax. Closer to human language than most computer languages. The current implementation is based on English, including simple math notation. (But note that this is not natural-language programming and not mind reading. You still need to learn the language.)
• Good (but not perfect yet) error messages. Little waste of human brain power.
• As much as possible within Meta's design model, as many errors as possible are caught early, at compile time, to reduce time needed for debugging and to increase reliability of the software.
• The compiler helps with trying out and converting code from several other, related languages. It detects some words and paths from other REBOL-like languages: REBOL 3, REBOL 2, Red, Red/System and Boron, and some words from the Logo, Lisp and Scheme language families. An error message will be produced, but when there is an alternative in Meta, this will be suggested.
• Influenced mostly by REBOL and other languages from the REBOL family, and further by Logo, C, Turbo-BASIC XL, MAC/65, Action!, PL65, ALGOL 68, OCaml, Miranda and Twentel, with some touches of Pascal and COBOL. The implementation is further influenced by Plan 9, LLVM and WebAssembly. REBOL itself was mainly influenced by Lisp, Forth, Logo and Scheme, and probably also by Smalltalk, Self, NewLISP, Rexx and a bit of C and BCPL.
• The language design is underpinned by the theory of denotational semantics.
• The language design is homo-iconic. Code is data (once implemented).
• The base language design has no grammar, or if you will, an unrestricted grammar. Dialects can be constructed from it that do have grammar. Any computer language could be constructed. To make this easier, the language does predefine the literal syntax of basic data types. This structures and standardises the form that dialects usually take.
• Among the basic data types are words, much like in human language.
• Since the base language has no grammar, there can be no default scoping rules. Instead, the language provides contexts, to which each instance of a word can be bound individually. Dialects can use this system of words, word instances and contexts to construct their own scoping rules.
• The default language dialect, which we call the do dialect, is an impure functional language, that also supports imperative programming, assisted by several embedded specification dialects.
• The functional language is a context-sensitive language, whereas most computer languages are more limited context-free languages. Some are even more limited regular languages.
• The functional language is based on multi-methods.
• The functional language supports parenthesised and parenthesis-free prefix symbolic expressions and infix operators.
• The functional language uses a special form of static/lexical scoping, called definitional scoping by REBOL's inventor.
• Light-weight abstractions of both native and external data types.
• The type system currently uses strong static typing, providing type safety with type inference, and will be extended to gradual typing.
• Elegant option types.
• Efficient range types/slices, avoiding unnecessary copying.
• The functional language will be memory safe (once implemented).
• The functional language uses one-based indexing. Compared to zero-based indexing, this is the human-friendly choice. However, it is not hard to do zero-based indexing.
• The language seamlessly integrates a 6502/6507 assembler dialect for systems that have this processor.
• The language implementation is designed around an Intermediate Representation.
• Multiple code generation back-ends: C transpiler, proofs of concept for WebAssembly and 6502/6507 machine code.
• The compiler produces stand-alone, freely distributable executable programs or web pages. Any needed parts of the Meta runtime are compiled in.
• Easy use through a remote build service and a web console. No complex toolchains to install, modify, configure and keep updated on your systems. We do that for you on our build server.
• Rapid development of the language through continuous deployment.
• The compiler client is currently available for web browsers, Windows, Apple MacOS, Linux, FreeBSD, NetBSD and OpenBSD.
• The compiler currently produces programs for web browsers, PC platforms and for Atari 8-bit home computers. Stay tuned for more.

### What Is It?

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?

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.

### Reducing Software Waste

"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.

### Why the Name?

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.

### Who Is It For?

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. Something can't be an improvement or innovative without being different. 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 most 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#:

### How It Works

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.

REBOL is the brain child of Carl Sassenrath, of previous fame as the chief designer of the innovative Commodore Amiga operating system, the first consumer multimedia system. REBOL was designed to enable the creation of Domain-Specific Languages (DSL's). Because REBOL DSL's use a different grammar than, but the same lexical syntax as the general-purpose main language, they are called dialects. They are executed in the REBOL interpreter. Dialects can not only contain program code, but also data formats. Because code is just a data dialect, it can be processed as data, allowing the language to manipulate its own code. REBOL inspired the creation of the popular JSON data dialect of JavaScript (The JSON Saga from 21:45). One of REBOL's hallmarks is a dialect for cross-platform definition of graphical user interfaces. In this way, programs are written in a combination of the main language and applicable DSL's. REBOL has a human-friendly syntax of great clarity and is highly productive. It has been measured to be the most expressive general-purpose language. When the general-purpose REBOL dialect is not optimal for a certain task, REBOL supports creating a special-purpose dialect that is optimal. This way, it is not needed to revert to entirely different DSL's that would cause a mismatch with the language. Creating dialects of both program code and data is so smooth, that it can be done routinely with small granularity. Programs will be built up out of dialects, allowing to approach the essential complexity of the task at hand.

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.

### Development Status

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, blazingly fast, efficient and with few dependencies - unless you need garbage collection of memory for long-running programs.

If you need support, contact us for consulting or contract development.

### Supported Platforms

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.

##### Smart Phones & Tablets
• Currently, Meta can be used on mobile devices through web browsers. In the future, there will also be native versions of Meta for specific mobile platforms.
##### Home Computers

Mortal Coil Atari 8-bit graphics & sound demo in Meta

##### Game Consoles

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.

### Road Map

Current priorities, in order. Because much depends on support from the community and funding by organisations, there is no time schedule for these developments. 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.

##### Done
• Developed Meta into a Minimum Viable Product. This will be a base language with approximately the feature set and type system of medium-level languages such as C and Pascal in a safe form, made friendlier by a high-level REBOL-like syntax.
• Developed a web download server written in Meta itself, to support the project and develop the language.
• Introduced the project to the Atari 8-bit scene as a suitable grass-roots audience, to start a feedback process.
• Created a project website, served by Meta.
• Introduced the project to the REBOL audience, Meta's predecessor.
• Developed an Internet build server and client written in Meta, for easy and continuous deployment of the language.
• Launched the language as a cross compiler on PC to Atari 8-bit, a suitable combination of target and host platform to make a start.
• Released the language for popular PC platforms themselves.
• Released the language for web browsers, for even easier entry and coverage of more platforms.
• Developed a custom forum system for the project, using Meta itself and served by Meta.
• Introduced the project to the αcτµαlly pδrταblε εxεcµταblε & Cosmopolitan community, which we support as a target runtime.
##### In Progress
• Incrementally improve the language, build services, documentation and program examples from the feedback of their use.
• Use Meta for tasks in other projects.
• Introduce the project to more audiences.
• Build an inclusive community, where anyone with good intentions can feel welcome.
##### Medium Term
• Create a crowd-funding system using Meta, to fund the project and let users influence priorities.
• Release Meta for many target and host platforms to grow the user base.
• Develop paid premium products and services to sustain the business model.
##### Long Term
• Develop Meta further to implement REBOL's higher-level and dynamic features, and interface with external systems and libraries. Within these design and dependency constraints, there is a lot of room to let the crowd funding inspire the planning.
• Gradually modularise Meta more to open up the project to outside contributions.
• When Meta is capable enough, rewrite it from REBOL into itself.
• Gradually open-source more of the project's program source code.
• Because of its nature of making use of third-party open-source products, the server side of the product is hard to install and maintain. We will work towards a simpler version that can run independently on your local machine. This will take considerable work and time to achieve, and because of technical necessity, it will have limitations compared to the full product.

The audience chosen for early introduction are the Atari 8-bit and Atari 2600 communities, because 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.

### About the Author

Meta is being created by Kaj de Vos, with help from its community.

I am an N-Ach type personality. If you read that article, you will know most about me and my motivations.

### Community

We can have nice things, but we need to create them ourselves.

##### Forums

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.

### Contact

The project and its community can be contacted on its forum.

If you need to contact us privately, you can do so by email: metapr[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.

Copyright © 2021-2023,  Kaj de Vos