6502 JSON Parser

The JSON object parser library in 6502 assembly.


  1. About.

  2. Installation.

  3. Usage.

  4. Index of functions.

  5. License.

1. About.

6502 JSON Parser is a library created to parse valid JSON objects, written in 6502 assembly for Commodore 64, or any other 6502/6510 8-bit machine. It was written in 64tass cross-assembler (v1.53.1515) and is fully unit tested with c64unit test framework.

Where can it be useful? One of its use cases, and the reason why this library has been created, is that it provides an elegant solution to request data from APIs. In API world, especially REST API world, JSON format is one of the most common, lightweight and human friendly format available, and it will probably stay around for another decade. Because of that, I believe that supporting Commodore 64 and other 8-bit machines with the versatile 6502 JSON Parser will bring new ideas, and actively help to develop modern software for our beloved, small, but still in some way powerful machines.

You could easily use this JSON parser with http64 library written by Doc Bacardi which allows to make requests over HTTP. You can find source code here: http64 library is used in HTTP-Load, and Singular Browser, and works perfectly with RR-Net ethernet cartridge, or other devices.

You can also use JSON parser to organize your data, or to keep your configuration on the disk or cartridge - or anything else you wish for!


  • any given length of JSON can be parsed, it also applies to value length
  • static or stream parsing mode: JSON object can be downloaded at once before parsing, or can be parsed from open stream which can be useful for heavy responses
  • with just one line of code, it's an easy way to store array of strings, or integers in a table, without memory constraints
  • escape characters are supported for keys, and values (e.g. quotes escaped by backslash character)
  • option to convert ASCII characters to PETSCII, so they can be displayed on screen straight away
  • possibility to store not only values, but also keys (including length of these values and keys)
  • no zero-page addresses occupied (though it's configurable to do so), so you don't have to care about reserving one, and avoiding variable collisions
  • keys length is limited but configurable (up to 256 bytes)
  • nesting level of JSON elements up to 256 levels

2. Installation.

To add 6502 JSON Parser to your project, just copy install/6502-json-parser-dependency.bat (Windows), or install/ (Linux, Mac) script file from this repository to your main project folder. Execution of the script file creates vendor/6502-json-parser folder and clones this repository using Git version control system. It's recommended to list vendor folder in .gitignore file if you're using Git.

Then, in your code, just include the library, e.g.:

.include "../vendor/6502-json-parser/src/json-parser.asm"

3. Usage.

The best way to learn how to use a library is through examples. You'll find 6502 JSON Parser case-specific examples in unit tests in tests/test-cases folder.

However, a few words of explanation will show how flexible the 6502 JSON Parser is, and that it had been designed with simplicity in mind.

Static JSON object mode

First of all, you have to specify the memory location of a valid, full JSON object, e.g.:

setJsonObject myJsonObject

or, e.g. with fixed memory location:

setJsonObject $8000

This way the library will know where to start parsing. We don't need to specify end memory location of JSON object, as the parser assumes that a JSON object is valid, in other words, that the number of opening and closing brackets is equal.

Streamed JSON object mode

To parse JSON object from opened stream, you have to use setStreamedJsonObject method instead of setJsonObject, and write your own implementation for retrieving data, and for reading new data from stream. It can only be done by overriding two methods from the library: JsonParser.getByte which loads the current byte, and JsonParser.walkForward which buffers and reads data from stream.

Note: If Y register is used in these methods, you have to save it, as JSON Parser uses it as well. See tests/test-suite-stream-object.asm for reference.


The main idea behind the parser is level nesting. Assuming that a JSON object has a few levels, you have to specify what the parser should expect on each level, and perform appropriate action for particular case.

Let's discuss simple JSON object like this one:


On the first level of this object, you can expect two nested objects, with keys first_key and second_key:

    expectJsonKey "first_key", firstKeyIterator
    expectJsonKey "second_key", secondKeyIterator

    bne -

In this example, expectJsonKey function is going to look for occurrences of first_key, or second_key, and then it will jump to corresponding label firstKeyIterator, or secondKeyIterator where further actions need to be performed.

The order of keys appearance doesn't matter here as isJsonObjectCompleted is going to iterate all elements found. Also, some keys can be just ignored if we don't want to get data from these elements.

Then, the "iterators" will perform further actions on the next level. firstKeyIterator is going to parse an object, where colour key is expected:


    expectJsonKey "colour", colourIterator

    bne firstKeyIterator

And secondKeyIterator contains an array of strings, so we can get all values, and save them in memory with offset of 16 bytes (as an example) for each data value, which means that the next value will be added on the next 16 bytes:


    storeJsonValue coloursTableLocation, 16

    bne secondKeyIterator

Note that we've used isJsonArrayCompleted here instead of isJsonObjectCompleted, as parsing in this case is executed on array, not on an object.

coloursTableLocation is a pointer (LSB, set in any memory location including zero-page) to table location where data will be set, e.g.:

    .fill 16 * 10, 0 ; we're expecting maximum of 10 strings, 16 bytes each

    .word coloursTable ; we can point to table location statically if we're going to parse JSON only once

In the example above, coloursTableLocation can be set statically to point to the table, but you must be aware that if you're going to parse JSON again, this pointer will continue incrementing. If you want to put data in the same memory location as before, you need to reset the pointer to this table, so it makes more sense just to set it on each run with setJsonOutputMemoryLocation method, e.g.:

setJsonOutputMemoryLocation coloursTableLocation, coloursTable ; set pointers just before the start to parse JSON


    .word 0 ; in this case it doesn't matter what the value is, as setJsonOutputMemoryLocation will set it automatically

In this case, table will be overwritten with new data, so YOU have to take care to clear this memory location beforehand. Otherwise you can have data corruption.

We've almost finished. The last part which needs to be done is colourIterator where we're expecting a single integer:


    storeJsonValue colourIntegerLocation

Value will be stored under location set by colourIntegerLocation pointers (omitted here, but done the same way as for coloursTable).

And that's it. See index of functions to learn more.

4. Index of functions.

expectAnyJsonKey <iteratorFunction>

expectJsonKey "<key>", <iteratorFunction>




setJsonObject <jsonObjectMemoryLocation>

setJsonOutputMemoryLocation <memoryLocationPointer>, <memoryLocation>



storeJsonKey <memoryLocationPointers>, [<memoryOffset>]

storeJsonKeyLength <memoryLocationPointers>, [<memoryOffset>]

storeJsonValue <memoryLocationPointers>, [<memoryOffset>]

storeJsonValueLength <memoryLocationPointers>, [<memoryOffset>]

5. License.

Copyright © 2017, Bartosz Żołyński, Commocore.

Released under the GNU General Public License, version 3.