Written by Irmen de Jong (irmen@razorvine.net)
This is a structured programming language for the 8-bit 6502/6510/65c02 microprocessor from the late 1970's and 1980's as used in many home computers from that era. It is a medium to low level programming language, which aims to provide many conveniences over raw assembly code (even when using a macro assembler).
Want to buy me a coffee or a pizza perhaps?
This project was created over the last couple of years by dedicating thousands of hours of my free time to it, to make it the best I possibly can. If you like Prog8, and think it's worth a nice cup of hot coffee or a delicious pizza, you can help me out a little bit over at ko-fi.com/irmen.
Full documentation (syntax reference, how to use the language and the compiler, etc.) can be found at: https://prog8.readthedocs.io/
prog8
Most of the development on Prog8 and the use of it is currently centered around the Commander X16 retro computer. Their discord server contains a small channel dedicated to Prog8. Other than that, use the issue tracker on github.
GNU GPL 3.0 (see file LICENSE), with exception for generated code:
when
statement to provide a concise jump table alternative to if/elseif chainsin
expression for concise and efficient multi-value/containment check lsb
, msb
, min
, max
, rol
, ror
Rapid edit-compile-run-debug cycle:
Multiple supported compiler targets (contributions to improve these or to add support for other machines are welcome!):
64tass - cross assembler. Install this on your shell path. A recent .exe version of this tool for Windows can be obtained from my clone of this project. For other platforms it is very easy to compile it yourself (make ; make install).
A Java runtime (jre or jdk), version 11 or newer is required to run a prepackaged version of the compiler. If you want to build it from source, you'll need a Java SDK + Kotlin 1.3.x SDK (or for instance, IntelliJ IDEA with the Kotlin plugin).
It's handy to have an emulator (or a real machine perhaps!) to run the programs on. The compiler assumes the presence of the Vice emulator for the C64 target, and a recent emulator version (R42 or newer) for the CommanderX16, such as x16emu (preferred, this is the official emulator. If required, source code is here). There is also Box16 which has powerful debugging features.
Syntax highlighting: for a few different editors, syntax highlighting definition files are provided. Look in the syntax-files directory in the github repository to find them.
This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
%import textio
%zeropage basicsafe
main {
bool[256] sieve
ubyte candidate_prime = 2 ; is increased in the loop
sub start() {
sys.memset(sieve, 256, 0) ; clear the sieve
txt.print("prime numbers up to 255:\n\n")
ubyte amount=0
repeat {
ubyte prime = find_next_prime()
if prime==0
break
txt.print_ub(prime)
txt.print(", ")
amount++
}
txt.nl()
txt.print("number of primes (expected 54): ")
txt.print_ub(amount)
txt.nl()
}
sub find_next_prime() -> ubyte {
while sieve[candidate_prime] {
candidate_prime++
if candidate_prime==0
return 0 ; we wrapped; no more primes
}
; found next one, mark the multiples and return it.
sieve[candidate_prime] = true
uword multiple = candidate_prime
while multiple < len(sieve) {
sieve[lsb(multiple)] = true
multiple += candidate_prime
}
return candidate_prime
}
}
when compiled an ran on a C-64 you'll get:
One of the included examples (wizzine.p8) animates a bunch of sprite balloons and looks like this:
Another example (cube3d-sprites.p8) draws the vertices of a rotating 3d cube:
If you want to play a video game, a fully working Tetris clone is included in the examples:
There are a couple of examples specially made for the CommanderX16 compiler target. For instance here's a well known space ship animated in 3D with hidden line removal, in the CommanderX16 emulator: