Julian's Long List of Ideas Thread

[zhulien]

Hi,

I figured I will start this thread and try keep my ideas in here, up to you if you want to ignore them or read them.

[zhulien]

- UNIDOS Stream ROM - in progress, proven some cool things can be done to extend BASIC, coded in Z80
 

This ideas was to create an easy way of exposing drivers or other functionality to BASIC in a way that BASIC only has to read/write to them like files.  As of now, in a POC state, proves the idea works.

https://github.com/PrimalNinja/Streamer

[zhulien]

- 8bitology API and SDK: for in-game lobby, messaging, achievements (mostly running and live at 8bitology.net), coded in JS and PHP

This idea is to provide internet functions for CPC, sort of like a proxy.  The API is available and running now, the status of it is documented in the AIP Ref section of the website

http://8bitology.net/

[zhulien]

- 8BML browser to bring web browsing to CPC, protocol and SDK already available for years at 8bitology.net as well as logic for the browser (not yet coded on CPC), coded in JS and PHP

The SDK and protocol is documented and working now for some years, I didn't yet create a real 8BML client yet though.  There is documentation on the website.

http://8bitology.net/

[zhulien]

- Virtual Display Units (VDU) for CPC API: been online for ages, please someone put support for it in your game and / or utilities - it gives CPC software the ability to display stuff on any of your old redundant displays laying around that may include a web browser: Wii, PS4, Xbox One, PC, Android Phones/Tablets, iPhones/iPads and smart TVs - an unlimited number of them!!! graphics can be added, we could put sound if wanted but it isn't there yet. display debug info in there when you are programming, run-time game comentary for anyone in the World to view... it's sort of a BETA but been online for years now, coded in JS and PHP

A POC is here.

http://8bitology.net/poc/vdu/

Documentation currently as follows: ( previously posted here: https://www.cpcwiki.eu/forum/programming/unlimited-number-of-networked-displays-api-for-m4-and-other-connected-devices/ )

I have created the first working version of my networked display API.  There is very little left to do to make it useful, then it can only get more useful from then as I add further commands to the API.


What is it?


Imagine you have all these old devices laying around your place, some useless old phones, tablets, smart TVs, PS3s, Wiis, PCs etc... or you just want some extra screen real-estate... so you stick them all on your desk and wall near your CPC... or you want to display information for the World to watch... status information?  debug information? etc...


You can now do that from your CPC.  With an unlimited number of networked screens for your game or application, with CPC-style Windows support too.  And they generally update at 10 frames per second from the server - almost suitable for real-time internet games!!!


How does it work?


First setup a channel.  You need a private channel GUID (or code) that no-one else knows.  It shouldn't be told to anyone as it is what gives you permissions to update the screens and windows within your channel.  You can give your channel a unique public name though which everyone can know - of course you can even create a private channel that is not known to anyone but yourself (and set it visible later if you like, or never - don't put really private stuff in there though, as there is no HTTPS for now on CPC is there).  This private channel GUID should really be read from a central config file on your SDCard so that all your games and apps can use your channel.


Second setup a screen, or as many screens as you need.  These screens you would normally create dynamically when your game or application starts - afterall, if you have a bunch of CPCs that you all use your channel, you don't want them all writing to the same screen do you?  But you can also have as many screens for your one game or application as you like - a status screen?  a debug screen?  a 24bit graphics screen?  All updated in realtime from your CPC to the rest of the World and your other devices.


Thirdly (optionally) setup some Windows, CPC style on your screens.  These are just labelled regions of your screen which you can use relative locating and printing to...


Fourthly, do something on your screen.  Locate, Print, clear the screen... more to come...  The screens are not static, they are 100% dynamically updated over the internet as fast as your internet connection allows on your display devices - but i have capped it at 10fps for now.


Lastly...  Connect your devices!  Yep, you can go to the channel index, or directly to your own channel to see all your screens.  Alternatively you can even bookmark a specific screen if you know the code (it should be dynamic, but depends how you choose to use them).


Commands for the POC environment:


NOTE: All the below examples, prefix with the following:  http://8bitology.net/poc/vdu/vdu.php


newchannel:


?function=channel&cmd=newchannel&ownerguid=<your private channel guid>&channel=<your public channel name>&description=<a text description of your channel>
eg: ?function=channel&cmd=newchannel&ownerguid=ABCD&channel=batman&description=I%20really%20am%20Batman


newscreen:



?function=screen&cmd=newscreen&owner=<your private channel guid>&ownerguid=<your private screen GUID>&publicguid=<your public screen guid>
eg: ?function=screen&cmd=newscreen&owner=ABCD&ownerguid=XYZ&publicguid=batmask


newwindow:



?function=window&cmd=newwindow&screen=<your private screen guid>&window=<your windowcode>&x=<x position>&y=<y position>&w=<width>&h=<height>
eg: ?function=window&cmd=newwindow&screen=XYZ&window=1&x=1&y=10&w=40&h=5


locate:


?function=window&cmd=locate&screen=<your private screen guid>&window=<your windowcode>&x=<x position>&y=<y position>
eg: ?function=window&cmd=locate&screen=XYZ&window=1&x=15&y=1


print:


?function=window&cmd=print&screen=<your private screen guid>&window=<your windowcode>&text=<the text to print>
eg: ?function=window&cmd=print&screen=XYZ&window=1&text=I am Batman!


Channel Index:  http://8bitology.net/poc/vdu/


Internet Call Demo: http://8bitology.net/poc/framework/itpdemo.htm


Sprite Demo: http://8bitology.net/poc/framework/spritedemo.htm (yep, I have coded sprites too but not yet collision detection).  These sprites will soon be in the networked display and more.



optional &tag=<tag> can now be added to all window functions.


What this allows is eg: you setup a display, you can simply update a tagged function in-place with a single call instead of having to re-create the display.


Some uses:


You can put a score somewhere with print given a tag of score (?function=window&cmd=print&screen=XYZ&window=1&tag=score&text=0).  You can then just update the score by issuing a replacement command for that specific tag (?function=window&cmd=print&screen=XYZ&window=1&tag=score&text=100).



You can put something somewhere on the screen and locate with a tag such as position (?function=window&cmd=locate&screen=XYZ&window=1&tag=position&x=1&y=1).  You can then just update the position by issuing a replacement command for that specific tag (?function=window&cmd=locate&screen=XYZ&window=1&tag=position&x=1&y=2).  Repeat this and it animates.


Anyone think this is useful enought to continue with?

[zhulien]

- JSASM (proven) the dev environment can work, translator to z80 is not started, coded in JS*

* I was thinking of making my VB6 cross compiler and JS cross compiler all share the same code generator in the end... but if anyone is to use them but me, input is most welcome...

https://www.cpcwiki.eu/forum/programming/jsasm-js-virtual-assembler/
https://github.com/PrimalNinja/jsasm

[zhulien]

- Visual BASIC 6 (very large subset) cross compiler for CPC, and it can correctly parse itself - the code generator is unfinished, coded in VB5/VB6 (either work) *

Visual BASIC cross compiler, not completed but you can see where it's going and it can compile itself

https://github.com/PrimalNinja/vbcc

[zhulien]

- JavaScript (subset) cross compiler for CPC, and it can correctly parse itself - the code generator is unfinished, coded in JS (cannot compile itself) *

https://github.com/PrimalNinja/jscc

more of a POC at the moment, I have now some other ideas relating to this.

https://youtube.com/video/q8kBgWHT944

[zhulien]

- I created a POC of virtual Z80s as a webservice where you can prepare a memory model and have it execute code and return a response.  The POC is no longer online and was based on an open source GB Z80 (missing some typical Z80 instructions).

Any use? You could make a cluster of 1000s of them in AWS.

https://www.cpcwiki.eu/forum/programming/z80-clusters/

note: I did get a 2nd CPLink card so multiple can run at once in the same CPC too - the goal of this is related to the virtual Z80 in the cloud.  If I can finalise the API to work with 2, then it can also be 4 (across to a 2nd wifi connected CPC) or more (to the cloud) via a single API.

btw, EVERYONE please get yourself a CPC-CPLINK card or two!!!    https://www.cpcwiki.eu/forum/amstrad-cpc-hardware/cpc-cplink-a-coprocessor-interface-card-for-all-cpcs

[zhulien]

- Stack Programming.

I am planning to code a better demonstration of highly performant Z80 code.  I've been brainstorming a BASIC compiler to 'optionally' generate this code too so both typical code and stack based code can be directly compared.  Likely a subset of Locomotive BASIC - which relates to my JSCC ideas above - why not allow subsets of JS, Locomotive BASIC and C all compile to the same source.

https://www.cpcwiki.eu/forum/programming/stack-programming/msg245465

[zhulien]

- PrimalOS: let's call it early alpha is there in github, to allow multiple computers to run the same software - in itially text-only, but... not limited to that if you don't mind breaking compatability... it's not that complex like FutureOS or Symbos... but also at this moment not so important, coded in Z80

https://docs.google.com/spreadsheets/d/14JQa3cTEd9fIz9lyoQRkzVc5xBz5FhEdr_DC41xPkJs/edit
https://github.com/PrimalNinja/Primal

Still more to do, I did a minor update late last year so it is a work in progress I plan to finish.

[zhulien]

- MCP / MOS - Multitasking mini kernel for AMSDOS drivers, proven and working but doesn't do a lot yet - perhaps this can share drivers with PrimalOS? feedback welcome, coded in Z80

https://drive.google.com/drive/folders/1Xvirgaep8dHFQUSaQxa5aQRV_SIbAfbR

What I think is cool is the current POC code there (you can build the ROM and play) allows you to run code in the background, even reset the CPC and have it optionally resume.

Why? Before the advent of M4 cards and such where we can store autoexecs on the SDCARD, there was no way to resume something...

I'd love to work with someone in the CPC World on a driver standard if they don't like what I've done so far.

[zhulien]

- Locomotive Shell ROM - in progress, proven a custom shell based on BASIC is very viable, the plan could be to integrate MOS with Primal compatible drivers and design a very nice user experience as an alternative to BASIC, coded in Z80

and

- Locomotive BASIC 2 ROM - in progress, proven the language can be extended, and likely in a backward compatible way (at least to a high percentage) with current BASIC, coded in Z80

These are very closely related - they are new replacements for the existing Locomotive BASIC based on Bread80s ROM disassembly.

https://www.cpcwiki.eu/forum/programming/extending-locomotive-basic

Very interesting results and if anyone wants it put online to continue working on it, happy to do so.

[zhulien]

- My first hardware project (beyond simple switches and piggybacked ROMs), I guess a bit dead in the water after having obtained all the parts necessary.  Although I have lots of research suggesting it is possible to use a standard Pi to behave as a CPU, whether the timings can be tight enough for a CPC hardware expansion are uncertain still.  Lots of docs here and maybe Pi 5 is now faster enough?  CPLink gives an awesome "different" way to give some features in software, that is proven!

https://www.cpcwiki.eu/forum/amstrad-cpc-hardware/cpc-raspberry-pi-bridge-card/

[zhulien]

- Network Card driver for a game I am making, game is mostly designed but I am having difficulty developing it for now when I don't have a usable monitor for my CPC where I live.  The driver will be coded in Z80 (and work with 2 CPC network cards), game details will be anounced when I get the driver working.

yes, I failed to do simple data transfers in both the M4 as well as they Cyboard.  Grrr

If I can resolve that, I can then create a ROM that gives an 8bitology API RSX set and examples in assembly for using it in games.  Also if included in MCP ROM above, then we can simply send and receive messages between CPC users via CPC Basic RSXs.

[zhulien]

- CPC online multiplayer games, server-side POC already up and running, prove that we can design a game together, coded in JS and PHP

Server Side has been online for ages, can't find the thread now in the forums - but the Network Card code I need working first before I can make a real CPC talk to it.

[zhulien]

- Web based development environment with source control, modules and more (I think it's somewhat cool), coded in Z80 - would be more useful when the JavaScript cross compiler is more working... but can work with Z80 now if people wanted it to, just still thinking of the features to expose, coded in JS and PHP (this is the only somewhat closed source project of them all - but it could turn into the World's best dev environment - or not)

This is currently working but not currently public.  Debating whether it's worth to extend this to allow for an online dev environment for CPC (and other platforms).

[zhulien]

- Web based environment for new SlaveOS.  I am debating using the Web based development environment above vs a fresh open source minimal for this... mainly because the environment already has a document repo and ESB (enterprise service bus) built in.

Imagine you code an implementation of SlaveOS for your Commodore 64 (Blah 64) and your Amstrad CPC (Blah CPC).  Could just be a ROM on CPC you type |iamslave,"BLAHCPC","PUBLIC" or |iamslave,"BLAHCPC","PRIVATE" <-- CPC displays a code, or QRCode or 2D barcode

what it would do is connect to the server, and say, hey, I have speech synthesizer capability and AY-8-8912 music file playback capability and text output.  Or a C64 might say I have SID playback capability and text output.

Another program, on another computer that isn't a slave, can connect to the server and say, hey, what slaves are available for me?  SID Playback on Blah 64, text output on Blah 64, AY-3-8912 playback on Blah CPC, text output on Blah CPC.  This 'another' computer could be another CPC, C64, Smart Phone, PC or whatever anywhere around the World.  Any capabilities can be published and subscribed to and... our beloved old computers can joing the IOT World.

[zhulien]

SlaveOS API

|iamslave,"BLAHCPC","PUBLIC" or "PRIVATE", the computer becomes a slave, either publshing a set of services from a local config file, or maybe a 2nd parameter to the RSX

|slaves, would ask the server to list all slaves
|slaves,"AY-3-8912", would ask for a list of all slaves with SID playback
|slave,"BLAHCPC" would list all services on BLAHCPC
|order,"BLAHCPC"," AY-3-8912 ",<sidfile> would send the server the AY-3-8912 file for BLAHCPC to play

[zhulien]

- Stack Programming.

Here is an example if someone wants to fill in the fast print char function (remember: don't use call or push).  and... the mode command, or just change the kw_mode to kw_cls

I put my hand coded example in the comments too, the purpose is not to create the most optimal assembly language program - that is likely by hand but... interestingly depending on some factors the stack programming can actually be faster AND smaller than the hand coded.

** if a program spends more time calling keywords in a function than calling functions, then the stack programming approach is positive **

but the goal is... to see how well potentially compiled code can be.  I am aware I can generate better examples of compiled code too with the keywords provided, just trying to think how a simple compiler might execute without much optimisation.  such as jumping over the loop to return is slower than a return_iftrue...

Code Select Expand


;restrictions
; interrupts must be disabled
; don't use call or push

;prefix key
; fn = subroutine called via kw_gosub, returned via kw_return
; kw = keyword statement, ends in any ret

;keywords implemented:

;flow control:
; kw_gosub, <label>
; kw_gosub_iftrue, <label>
; kw_gosub_iffalse, <label>
; kw_goto, <label>
; kw_goto_iftrue, <label>
; kw_goto_iffalse, <label>
; kw_return
; kw_return_iftrue
; kw_return_iffalse
; kw_stop

;logic:
; kw_dec8, <label>
; kw_dec16, <label>
; kw_inc8, <label>
; kw_inc16, <label>
; kw_iszero8, <label>
; kw_iszero16, <label>
; kw_let8, <label>, <value>
; kw_let16, <label>, <value>

;other:
; kw_cls
; kw_locate, <x>, <y>
; kw_mode, <n>
; kw_print, <stringaddr>

; ==============================================================================

; setup code

org #100

di
ld sp, main
ret

; ==============================================================================

; 10  gosub 30
; 20  stop

; 30  mode 1
; 40  for counter = 1 to 5
; 50    print "Hello"
; 60    print "Goodbye"
; 70    print "Hello"
; 80    print "Goodbye"
; 90    print "Hello"
; 100   print "Goodbye"
; 110   print "Hello"
; 120   print "Goodbye"
; 130 next counter
; 140 return

; typical handcoded:
;
; main:
; call fn_printscreen ; 3 bytes, 5 nops
; ret ; 1 byte, 3 nops
;
; fn_printscreen:
; ld a, 1 ; 2 bytes, 2 nops
; call kw_mode ; 3 bytes, 5+3 nops
;
; ld b, 5 ; 2 bytes, 2 nops
; fn_printscreen1:
; push bc ; 1 byte, 4 nops

; ld hl, msg_hello ; 3 bytes, 3 nops
; call kw_print ; 3 bytes, 5+3 nops
; ld hl, msg_goodbye ; 3 bytes, 3 nops
; call kw_print ; 3 bytes, 5+3 nops
; ld hl, msg_hello ; 3 bytes, 3 nops
; call kw_print ; 3 bytes, 5+3 nops
; ld hl, msg_goodbye ; 3 bytes, 3 nops
; call kw_print ; 3 bytes, 5+3 nops
; ld hl, msg_hello ; 3 bytes, 3 nops
; call kw_print ; 3 bytes, 5+3 nops
; ld hl, msg_goodbye ; 3 bytes, 3 nops
; call kw_print ; 3 bytes, 5+3 nops
; ld hl, msg_hello ; 3 bytes, 3 nops
; call kw_print ; 3 bytes, 5+3 nops
; ld hl, msg_goodbye ; 3 bytes, 3 nops
; call kw_print ; 3 bytes, 5+3 nops loopwork: 48 bytes, 88 nops x 5 = 440 nops

; pop bc ; 1 byte, 4 nops
; djnz fn_printscreen1 ; 3 bytes, 5 nops work: 5 bytes, 13 nops x 5 = 65 nops

; ret ; 1 byte, 3 nops
; ; total 65 bytes, 528 nops (caters for the 5 iterations)

main:
dw kw_gosub, fn_printscreen ; 10, 2 words, ? nops
dw kw_stop ; 20, 1 word, 3 nops

fn_printscreen: ; 30
dw kw_mode, 1 ; 30, 2 words, 3 nops
dw kw_let8, var_counter, 5 ; 40, 3 words, 3 nops

fn_printscreen1: ; 40
dw kw_iszero8, var_counter, kw_goto_iftrue, fn_printscreen2 ; 40, 4 words, 6 nops
dw kw_print, msg_hello ; 50, 2 words, 3 nops
dw kw_print, msg_goodbye ; 60, 2 words, 3 nops
dw kw_print, msg_hello ; 70, 2 words, 3 nops
dw kw_print, msg_goodbye ; 80, 2 words, 3 nops
dw kw_print, msg_hello ; 90, 2 words, 3 nops
dw kw_print, msg_goodbye ; 100, 2 words, 3 nops
dw kw_print, msg_hello ; 110, 2 words, 3 nops
dw kw_print, msg_goodbye ; 120, 2 words, 3 nops loopwork: 8 words (16 bytes), 24 nops x 5 = 120 nops
dw kw_dec8, var_counter, kw_goto, fn_printscreen1 ; 130, 4 words, 6 nops loop: 8 words (16 bytes), 12 nops x 5 = 60 nops

fn_printscreen2: ; 40

dw kw_return ; 140, 1 word, ? nops
; total 33 words (66 bytes), 189+ nops (caters for the 5 iterations)

; ------------------------------------------------------------------------------

var_counter: db 0

msg_hello: db "Hello", 0
msg_goodbye: db "Goodbye", 0

; ==============================================================================

kw_gosub:
pop bc ; where do we want to go, pop it first as we want
; the next statement upon kw_return

ld hl, 0 ; hl = hsp
add hl, sp

ld de,(ssp) ; de = ssp
ex de, hl ; hl = ssp, de = hsp

ld (hl), e ; push hsp on the ssp
dec hl ;
ld (hl), d ;
dec  hl ;

ld (ssp), hl ; store the new ssp

ld l, c
ld h, b
ld sp, hl
;end of kw_gosub

kw_gosub_iftrue:
pop bc ; where do we want to go, pop it first as we want
; the next statement upon kw_return
ret z

ld hl, 0 ; hl = hsp
add hl, sp

ld de,(ssp) ; de = ssp
ex de, hl ; hl = ssp, de = hsp

ld (hl), e ; push hsp on the ssp
dec hl ;
ld (hl), d ;
dec  hl ;

ld (ssp), hl ; store the new ssp

ld l, c
ld h, b
ld sp, hl
;end of kw_gosub_iftrue

kw_gosub_iffalse:
pop bc ; where do we want to go, pop it first as we want
; the next statement upon kw_return
ret nz

ld hl, 0 ; hl = hsp
add hl, sp

ld de,(ssp) ; de = ssp
ex de, hl ; hl = ssp, de = hsp

ld (hl), e ; push hsp on the ssp
dec hl ;
ld (hl), d ;
dec  hl ;

ld (ssp), hl ; store the new ssp

ld l, c
ld h, b
ld sp, hl
;end of kw_gosub_iffalse

kw_goto:
pop hl
ld sp, hl
;end of kw_goto

kw_goto_iftrue:
pop hl
ret z

ld sp, hl
;end of kw_goto_iftrue

kw_goto_iffalse:
pop hl
ret nz

ld sp, hl
;end of kw_goto_iffalse

kw_return: ; do a software return

ld hl, (ssp) ; get the ssp

inc hl ; pop hsp from ssp
ld d, (hl) ;
inc hl ;
ld e, (hl) ;

ld (ssp), hl ; store the new ssp

ex de, hl ; hl = hsp, de = ssp
ld sp, hl
;end of kw_return

kw_return_iftrue:
ret nz ; if z we want to do a software return

ld hl, (ssp) ; get the ssp

inc hl ; pop hsp from ssp
ld d, (hl) ;
inc hl ;
ld e, (hl) ;

ld (ssp), hl ; store the new ssp

ex de, hl ; hl = hsp, de = ssp
ld sp, hl
;end of kw_return_iftrue

kw_return_iffalse:
ret z ; if nz we want to do a software return

ld hl, (ssp) ; get the ssp

inc hl ; pop hsp from ssp
ld d, (hl) ;
inc hl ;
ld e, (hl) ;

ld (ssp), hl ; store the new ssp

ex de, hl ; hl = hsp, de = ssp
ld sp, hl
;end of kw_return_iffalse

kw_stop:
halt
;end of kw_stop

; ------------------------------------------------------------------------------

kw_dec8:
pop hl
dec (hl)
ret
;end of kw_dec16

kw_dec16:
pop hl
ld e,(hl)
inc hl
ld d, (hl)
dec de
ld (hl), d
dec hl
ld (hl), e
ret
;end of kw_dec16

kw_inc8:
pop hl
inc (hl)
ret
;end of kw_dec16
;end of kw_inc

kw_inc16:
pop hl
ld e,(hl)
inc hl
ld d, (hl)
inc de
ld (hl), d
dec hl
ld (hl), e
ret
;end of kw_inc

kw_iszero8:
pop hl
ld a, (hl)
or a
ret
;end of kw_iszero8

kw_iszero16:
pop hl
ld e, (hl)
inc hl
ld d, (hl)
ld a, e
or e
ret
;end of kw_iszero16

kw_let8:
pop hl
pop de
ld (hl), e
ret
;end of kw_let8

kw_let16:
pop hl
pop de
ld (hl), e
inc hl
ld (hl), d
ret
;end of kw_let16

; ------------------------------------------------------------------------------

kw_cls:
ld hl,#c000
ld de,#c001
ld bc,#3fff
xor a
ld (hl), a
ldir
ret
;end of kw_cls

kw_locate:
pop de
ld (var_cursorx), de
pop de
ld (var_cursory), de
ret
;end of kw_locate

kw_mode:
;TODO: set the mode

ret
;end of kw_mode

kw_print:
pop hl
kw_print1: ld a,(hl)
or a
ret z

;TODO: output a char

inc hl
jr kw_print1
;end of kw_print

; ------------------------------------------------------------------------------

ssp: dw sss ; software stack pointer
ssb: ds 128 ; bottom of software stack
sss:
; start of software stack

; ------------------------------------------------------------------------------

var_cursorx: dw 0
var_cursory: dw 0



[zhulien]

- Stack Programming.

Just a thought... I might be able to optimise the software stack a little too, but it serves the demonstration purpose. Code is untested but it does assemble.

Typical code example:

Total bytes: 65
Total nops: 528

Stack example:

Total bytes: 66
Total nops: 189+

The + for total nops in the stack example is because the software stack overhead of the single software call.  The DJNZ also helps a lot in the handcoded example.


timings from: https://www.cpcwiki.eu/imgs/b/b4/Z80_CPC_Timings_cheat_sheet.20230709.pdf


The thing I never got with all traditional programming, why return back to the logic after calling a keyword just to go back to the next keyword... this allows keywords to go directly from one to the next.  If only they made a  cpu with 2 stacks, an execution stack and a call stack.

[Prodatron]

I wonder why you don't finally complete one of your ideas and turn it into a useful product?

[Pollo]

Ideas are a dime a dozen. It's execution that counts.
— Frank Herbert

[zhulien]

I wonder why you don't finally complete one of your ideas and turn it into a useful product?

Complete or make useable?  I have many completed (depending on your definition) but so far no uptake, so more ideas come and will become Siamese ideas when combined.

Nobody wants online highscores or achievements or game lobby in cpc games it seems... so maybe I need to make a ROM so basic programmers can. Maybe they still won't. Maybe a 8bml browser but the  Maybe only me makes websites with the sdk.   

Maybe nobody wants to display debug info from their cpc or game info or commentary on remote displays private on their desk or across the world like a chess game commentary.

But... for me it is fun creating them.

[eto]

How can I use the VDU from the CPC? All the examples just specify the URL but what hardware/software on the CPC is required?