This question may have the apparent form of a question soliciting a "list" answer, but I'm expecting the list to be very short, so please bear with me.

What "unusual" syntax assembly languages are/were there? My reason for asking this was that the first assembly language programming I did was on the English Electric KDF9, whose weird and wonderful assembly syntax is described below.

That needs some explanation for sure.

Most assembly languages for current handware follow a fairly similar lexical stucture. The opcode maps to a alpahbetic symbol (occasionally augmented by digits or a couple of other characters, for example period or underscore)., generally suggesting a verb. An instruction has an optional label, followed by the opcode symbol, followed by the operands. The operands may include a handful of symbols which indicate indexing, indirection, address mode, etc.

That is, despite the variation in specifics, the general pattern is like

LABEL: LOAD REG,FOO ADD REG,BAR STORE REG,FOO

So that's the sort of pattern I'm not interested in, for this question. A few weird delimiters added to the above don't count either.

In prestandard days, though, there were sometimes interesting variations.

Example 1

KDF9 Usercode, admittedly a fairly impoverished assembly language (no arbitrary user-defined symbols!) had what has been described as 'distributed syntax'. For example, an indexed load from memory to stack ("nest" in KDF9 terminoolog) is written like

V42M7Q;

'V42' is the name of some data item (no arbitrary user-defined symbols!), M7 means 'modified by register 7', and Q means that the modifier is to be incremented afterwards. (Where other machines had 'index registers', KDF9 had 'Q-registers', divided into modifier, counter, and increment parts, uxeful for indexing, base addresses, counting, and array access). The operation was implicitly a fetch; store would be indicated by '='.

Adding two numbers would thus look like

V42; V43; +; =V42; (FOO = FOO + BAR);

This is "fetch V42 to stack; fetch V43 to stack; add top 2 stack words and leave sum on stack; pop stack and store in V42". The addition operation is indicated by '+' and not by, say, 'ADD'. It's a zero-address machine so the operands are implciit. The parenthetical clause is a comment. And newlines have no significance - this was fairly common in papertape cultures.

There were some data-manipulation instructions that did use 'words' for them, when there was no reasonably mnemonic symbol in the Flexowriter repertoire. For example, DUP; duplicated the top-of-stack value (i.e., pushed another copy on the stack).

Example 2

Manchester University's MU5 also had an interesting syntax. The addition example would be written as

ACC = FOO ACC + BAR ACC => FOO

ACC is the name of a machine register, obviously the accumulator. The rest of the symbols should be self-explanatory.

(Bio note: I have programmed on the KDF9. I never met the MU5, though it was discussed in undergrad courses as an exciting example of a machine designed for higher-level languages, that the guys over in Manchester were inventing. I know there's at least one MU5 programmer in this forum).

Not an example

I'm excluding things like Turing's programming system at Manchester, since that just consisted in typing whatever teleprinter symbol made up the next 5 bits of the instruction stream.

So: was that the extent of the scenic detour off the highway to dull standardization, or are there other interesting examples?

Clarification: for this question, the assembly language should have been intended in principle for human programmers to use to write programs. Languages only intended for communication between programs, say as communication between different stages of a programming system, are excluded. Also, I'm only interested in actual code. No pseudo-ops, no directives, no macro definitions or calls, and not data declarations either.