Disp is a programming language, with the goal of being a practical choice as a single programming languages across an organization.

This goal manifests itself as several sub-goals:

  • good performance for many use cases: reduces the need of learning a second, faster language once your primary one hits performance limits.
  • upgrading large codebases easily: reducing cost for major refactors, managing code across multiple code repositories.
  • maintainability and readability: large organizations will face some level of developer churn, and the person who originally wrote the code may no longer be there.

The specific features of Disp include:

  • homoiconic syntax: code is represented using standard data structures
  • macro support: function that can do compile-time syntax evaluation
  • compile-time execution: functions can execute on runtime, or compile time


Disp is not ready for use in any production project! Literally anything about the language can change until 1.0

You can see a recent code example here (solving the qualifier problem a for Google Code Jam 2008):

let n (int (read-line))
let i 0
while (not (eq i n))
	let s (Int (read-line))
	let possible-engines {}
	let j 0
	while (not (eq j s))
		let e (read-line)
		add possible-engines e true
		let j (+ j 1)
	let q (Int (read-line))
	let j 0
	let switches 0
	let seen-engines {}
	while (not (eq j q))
		let e (read-line)
		add seen-engines e true
		if (eq (count seen-engines) (count possible-engines))
			let seen-engines {}
			add seen-engines e true
			let switches (+ switches 1)
		let j (+ j 1)
	let i (+ i 1)
	print "Case #"
	print i
	print ": "
	println switches

To get a better understanding of where Disp shines, it’s recommended to read up on the features, and some disp-cases (use cases that inspired disp’s design).


Indices and tables