I've been testing for a few days now and after some bug fixes I think I can now release the new version of BASIC 65.EX (220316) into the wild. Which of course does not mean that there are no more bugs. I can never completely exclude that with the complexity. 
What is new now? Except for bugfixes, the commands for procedures have remained as they were in this version. Everything remains at least 99.9% compatible to BASIC 65 (in version 920300 from January 22, 2022). So everything that runs with it, runs also with the new BASIC 65.EX.
Completely new is now an inline assembler, which makes it possible with three new commands to use - in the manner of the inline assembler with the BBC BASIC - assembler routines as simply as possible in the interaction with BASIC. All 256 opcodes of the 65CE02 are supported and for jumps also labels can be used (thanks to the 2 pass assembler forward and backward).
Since I had to squeeze all this into the already small space in the ROM and I still wanted to remain compatible to the BASIC 65, I "cleaned up" and restructured a bit and very carefully in some places in the ROM.
Because of this memory limitation, the inline assembler is of course not what one usually expects from a complete assembler.
With wishes and suggestions "Macros would be still great!" I ask to consider that currently in the ROM still 17 bytes are free for program code. 
What does the inline assembler offer?
The key point is the new keyword .. (two dots) at the beginning of a BASIC line. These must stand in each case under the command line ASM. The first line, which does not begin with the keyword .. marks then the end of this assembler routine.
Thus one of the 256 assembler commands of the 65CE02 can be entered in each line. Please note that the parameters can only be entered in hexadecimal format. So $xx or $xxxx. Decimal numbers or variable names etc. are not recognized.
Here is an overview of the 256 possible assembler commands:
- 61 ADC ($nn,X)
- 71 ADC ($nn),Y
- 72 ADC ($nn),Z
- 69 ADC #$nn
- 65 ADC $nn
- 75 ADC $nn,X
- 6D ADC $nnnn
- 7D ADC $nnnn,X
- 79 ADC $nnnn,Y
- 21 AND ($nn,X)
- 31 AND ($nn),Y
- 32 AND ($nn),Z
- 29 AND #$nn
- 25 AND $nn
- 35 AND $nn,X
- 2D AND $nnnn
- 3D AND $nnnn,X
- 39 AND $nnnn,Y
- 06 ASL $nn
- 16 ASL $nn,X
- 0E ASL $nnnn
- 1E ASL $nnnn,X
- 0A ASL A
- 44 ASR $nn
- 54 ASR $nn,X
- 43 ASR A
- CB ASW $nnnn
- 0F BBR0 $nn,$nn
- 1F BBR1 $nn,$nn
- 2F BBR2 $nn,$nn
- 3F BBR3 $nn,$nn
- 4F BBR4 $nn,$nn
- 5F BBR5 $nn,$nn
- 6F BBR6 $nn,$nn
- 7F BBR7 $nn,$nn
- 8F BBS0 $nn,$nn
- 9F BBS1 $nn,$nn
- AF BBS2 $nn,$nn
- BF BBS3 $nn,$nn
- CF BBS4 $nn,$nn
- DF BBS5 $nn,$nn
- EF BBS6 $nn,$nn
- FF BBS7 $nn,$nn
- 90 BCC $nn
- 93 BCC $nnnn
- B0 BCS $nn
- B3 BCS $nnnn
- F0 BEQ $nn
- F3 BEQ $nnnn
- 89 BIT #$nn
- 24 BIT $nn
- 34 BIT $nn,X
- 2C BIT $nnnn
- 3C BIT $nnnn,X
- 30 BMI $nn
- 33 BMI $nnnn
- D0 BNE $nn
- D3 BNE $nnnn
- 10 BPL $nn
- 13 BPL $nnnn
- 80 BRA $nn
- 83 BRA $nnnn
- 00 BRK
- 63 BSR $nnnn
- 50 BVC $nn
- 53 BVC $nnnn
- 70 BVS $nn
- 73 BVS $nnnn
- 18 CLC
- D8 CLD
- 02 CLE
- 58 CLI
- B8 CLV
- C1 CMP ($nn,X)
- D1 CMP ($nn),Y
- D2 CMP ($nn),Z
- C9 CMP #$nn
- C5 CMP $nn
- D5 CMP $nn,X
- CD CMP $nnnn
- DD CMP $nnnn,X
- D9 CMP $nnnn,Y
- E0 CPX #$nn
- E4 CPX $nn
- EC CPX $nnnn
- C0 CPY #$nn
- C4 CPY $nn
- CC CPY $nnnn
- C2 CPZ #$nn
- D4 CPZ $nn
- DC CPZ $nnnn
- C6 DEC $nn
- D6 DEC $nn,X
- CE DEC $nnnn
- DE DEC $nnnn,X
- 3A DEC A
- C3 DEW $nn
- CA DEX
- 88 DEY
- 3B DEZ
- 41 EOR ($nn,X)
- 51 EOR ($nn),Y
- 52 EOR ($nn),Z
- 49 EOR #$nn
- 45 EOR $nn
- 55 EOR $nn,X
- 4D EOR $nnnn
- 5D EOR $nnnn,X
- 59 EOR $nnnn,Y
- E6 INC $nn
- F6 INC $nn,X
- EE INC $nnnn
- FE INC $nnnn,X
- 1A INC A
- E3 INW $nn
- E8 INX
- C8 INY
- 1B INZ
- 7C JMP ($nnnn,X)
- 6C JMP ($nnnn)
- 4C JMP $nnnn
- 23 JSR ($nnnn,X)
- 22 JSR ($nnnn)
- 20 JSR $nnnn
- E2 LDA ($nn,S),Y
- A1 LDA ($nn,X)
- B1 LDA ($nn),Y
- B2 LDA ($nn),Z
- A9 LDA #$nn
- A5 LDA $nn
- B5 LDA $nn,X
- AD LDA $nnnn
- BD LDA $nnnn,X
- B9 LDA $nnnn,Y
- A2 LDX #$nn
- A6 LDX $nn
- B6 LDX $nn,Y
- AE LDX $nnnn
- BE LDX $nnnn,Y
- A0 LDY #$nn
- A4 LDY $nn
- B4 LDY $nn,X
- AC LDY $nnnn
- BC LDY $nnnn,X
- A3 LDZ #$nn
- AB LDZ $nnnn
- BB LDZ $nnnn,X
- 46 LSR $nn
- 56 LSR $nn,X
- 4E LSR $nnnn
- 5E LSR $nnnn,X
- 4A LSR A
- 5C MAP
- 42 NEG
- EA NOP
- 01 ORA ($nn,X)
- 11 ORA ($nn),Y
- 12 ORA ($nn),Z
- 09 ORA #$nn
- 05 ORA $nn
- 15 ORA $nn,X
- 0D ORA $nnnn
- 1D ORA $nnnn,X
- 19 ORA $nnnn,Y
- 48 PHA
- 08 PHP
- F4 PHW #$nnnn
- FC PHW $nnnn
- DA PHX
- 5A PHY
- DB PHZ
- 68 PLA
- 28 PLP
- FA PLX
- 7A PLY
- FB PLZ
- 07 RMB0 $nn
- 17 RMB1 $nn
- 27 RMB2 $nn
- 37 RMB3 $nn
- 47 RMB4 $nn
- 57 RMB5 $nn
- 67 RMB6 $nn
- 77 RMB7 $nn
- 26 ROL $nn
- 36 ROL $nn,X
- 2E ROL $nnnn
- 3E ROL $nnnn,X
- 2A ROL A
- 66 ROR $nn
- 76 ROR $nn,X
- 6E ROR $nnnn
- 7E ROR $nnnn,X
- 6A ROR A
- EB ROW $nnnn
- 40 RTI
- 62 RTN #$nn
- 60 RTS
- E1 SBC ($nn,X)
- F1 SBC ($nn),Y
- F2 SBC ($nn),Z
- E9 SBC #$nn
- E5 SBC $nn
- F5 SBC $nn,X
- ED SBC $nnnn
- FD SBC $nnnn,X
- F9 SBC $nnnn,Y
- 38 SEC
- F8 SED
- 03 SEE
- 78 SEI
- 87 SMB0 $nn
- 97 SMB1 $nn
- A7 SMB2 $nn
- B7 SMB3 $nn
- C7 SMB4 $nn
- D7 SMB5 $nn
- E7 SMB6 $nn
- F7 SMB7 $nn
- 82 STA ($nn,S),Y
- 81 STA ($nn,X)
- 91 STA ($nn),Y
- 92 STA ($nn),Z
- 85 STA $nn
- 95 STA $nn,X
- 8D STA $nnnn
- 9D STA $nnnn,X
- 99 STA $nnnn,Y
- 86 STX $nn
- 96 STX $nn,Y
- 8E STX $nnnn
- 9B STX $nnnn,Y
- 84 STY $nn
- 94 STY $nn,X
- 8C STY $nnnn
- 8B STY $nnnn,X
- 64 STZ $nn
- 74 STZ $nn,X
- 9C STZ $nnnn
- 9E STZ $nnnn,X
- 5B TAB
- AA TAX
- A8 TAY
- 4B TAZ
- 7B TBA
- 14 TRB $nn
- 1C TRB $nnnn
- 04 TSB $nn
- 0C TSB $nnnn
- BA TSX
- 0B TSY
- 8A TXA
- 9A TXS
- 98 TYA
- 2B TYS
- 6B TZA
Furthermore you can define up to 41 labels per assembler routine. A label is specified with .. @xxxx. It must be exactly 4 characters or digits (not more and not less). So for example .. @0001 or .. @here or .. @AAAA.
Comments require a separate line each, which allows both // and ; or * as comment characters after the ...
Furthermore with .. ! it is also possible to directly specify bytes to be written to the respective memory address instead of an opcode. Here, in contrast to the assembler commands, decimal values and also numeric variables can be specified in addition to hex values.
To visually distinguish them from BASIC lines, the lines with .. are displayed in yellow in the listing.
What can't the inline assembler do?
It cannot define macros, variable names or constant names.
Labels can only be used for long branches and jumps.
It has no dissassembler. For this purpose the dissassembler integrated in MONITOR is more than useful.
The more extensive the assembler routine becomes, the more the limitations of the BASIC editor become important. For example, each line must still have a line number.
No errors are output during compilation except for missing or wrong labels at jumps or branches. If an assembler command cannot be recognized, then this line is simply skipped.
Therefore it is important to have saved the program in any case before starting it.
Assembler routines cannot damage the MEGA65, but they can cause a crash and the program is lost if it has not been saved. 
What are the advantages?
It is simply included in BASIC and is there immediately. Switch on and use it! 
It can be included uncomplicatedly in the BASIC program and also several routines independent of each other can be stored in the memory.
The assembler routines do not have to be reloaded extra or set with POKE sequences, but can be simply stored and loaded in readable assembler code together with the BASIC program.
Of course an assembler routine can also be stored separately with BSAVE if required.
The English and German manuals are still being revised and supplemented, so just as a first introduction and start a few short explanations of the new commands:
ASM <address>,<bank>
define start of an assembler routine
<adress> is a memory address ($2000-$BFFF) from which on the following code will be stored
<bank> is the bank (0,1,4,5) which should be used for the code.
.. <65CE02 assembler instruction>
bra/bne/beq/... @<label> (branch codes)
jmp/jsr @<label> (jmp codes)
.. @<label> (label has to be any exactly 4 letter/number string)
.. !<byte> [,<byte>] ...
CALL <address>,<bank> [,a,x,y,z,s]
calls the ML code which is stored at <address> in <bank>
hereby the values of the variables a&, s&, x&, y&, z& are written into the a,s,x,y and z registers
before returning to BASIC, the values of a,s,x,y and z registes are written into a&, s&, x&, y& and z&.
so it's easy to handle a small data exchange between BASIC and the assemblerroutine.
besides that you can also use CALL <address>,<bank> with additional arguments for the a,x,y,z and s register as you know it from the SYS command.
I also have a few screenshot examples here, so you can get a first impression of how the whole thing is conceived and designed. The programs are also all included on the attached D81 image.
And apart from all that there is also the new MAN command. This simply shows an overview of all available keywords.
The ROM can still be patched and downloaded from my site here. You just have to upload a 911001-ROM from the C65 (911001.bin) and when that has passed the correctness check, the BASIC 65.EX-ROM will be patched and offered for download.
As already mentioned, with 17 bytes of free space for program code in the ROM, the possibilities are more than limited, but I would still appreciate feedback. I would try to correct errors in any case.
If you want to try the new BASIC 65.EX, have fun with it! 
And if you have any questions, please ask! Especially with assembler routines the whole thing is quite complex and I surely forgot to mention one or the other thing here.
sorry couldn't resist the running gag...
. Good old 8 bit machines 
