Ozark is a compiled object-oriented language for building software that's readable and reusable. It builds on ideas from flow-based programming so that code can closely model real-world scenarios. Ozark has a simple, elegant syntax and is statically typed. The simplicity and uniformity allows Ozark code to be read and edited by other software.

Why another language?

While building Objects, a tool for visual programming, we ran into issues with the freeform nature of modern programming languages. An ideal language for visual development would have only one way to represent each possible instruction. Some communities (Python is a good example) limit the freeform nature by using idioms and linting their code, but to work with a visual tool, those constraints need to be built into the language.

Beyond 1-to-1 correspondence between code and a visual graph, we found other ways to improve on the modern object-oriented programming language. For example, Ozark code is optimized for readability by English speakers. Eventually, it will include code transation such that two people who speak different languages can work on the same code with everything (method names, control structures, EVERYTHING) represented in their native language, while producing structured code that's understandable by an advanced IDE (or... AI?)

Another upcoming feature is GO-like concurrency and parallelism, except in Ozark it's even simpler; Just dispatch a method call, and then you can defer the assignment of specific inputs & outputs, thus blocking any parallel execution until those variables are given a value.


Ozark uses the subject → verb → direct object(s) pattern from natural human language. Each line inside a method follows that pattern, except for conditional clauses (e.g. if.)

All variables in Ozark are pointers. Unlike other languages, inline pointers are not mutable. Instead, pointers connect the output of a method to the input of another method. The only mutable pointers are an object's properties (similar to instance variables in other languages), the expected outputs of the current method, and any deferred inputs to a dispatched method.

Ozark code is always operating on a small scope. There are no global pointers, so often the entire scope is visible during method design.

inheritance Food

property @plant: Plant
property @weight: Number
property @size: Number

extension setup & seed: Seed
	seed sprout -> assign to @plant

	assign 0.0 to @size
	assign 0.0 to @weight

method grow days: Number, rate: Number
	days * rate -> assign to @size
	size * 0.25 -> assign to @weight

Ozark does not have nested trees of indentation. Loops are declared on a single line, and conditional statements cannot be nested. Instead, a robust matching construct keeps logic trees simple.

Ozark's strengths are standardization and collaboration. Multiple developers of varying skill levels may work on a project using different tools, yet will produce similar code that is easy to read.

Similarly, Ozark files are a suitable save format for applications that generate code. This means that artificial intelligence or visual development tools can parse existing code into a working model.


A compiler can be invoked via command line with the ozark build command, specifying the initial class file and method. Upon execution, an instance of the class is created, and the method is invoked.

ozark create Gunshow.ozark.class --method begin